var decisionTree =
new Case( true, Array(
new Case ( function(n){ return n < 0; }, Math.sin ),
new Case ( function(n){ return n < 2; }, "0<= n < 2" ),
new Case ( true, "Greater than two " )));
decisionTree.evaluate(1); // evaluates to string "0<= n < 2"
decisionTree.evaluate(-Math.PI/2); // evaluates to -1
decisionTree.evaluate(5); // evaluates to string "Greater than two"
使用此实现，您可以任意嵌套您的树：
// Represents a predicate and corresponding action to take if predicate is a
// match.
//
// predicate : true or Function( object ) returning a boolean.
//
// action : One of Function, Case, Array of Cases or other value (see
// Case.evaluate as to how each is applied)
//
//
Case = function (predicate, action) {
this.predicate = predicate;
this.action = action;
};
Case.prototype = {
nomatch : { match : false },
match : function (v) { return { match : true, result :v }; },
// Recursively test Cases and applies corresponding action on
// `object`.
//
// The action applied depends on the datatype of `action`:
//
// - Function : evaluates to `action( object )`
//
// - Case : A subsequent test is performed. Evaluates to whatever
// the Cases action evaluates to.
//
// - Array of Cases : Subsequent tests are performed. Evaluates to whatever
// the action of the first matching Case evaluates to.
//
// - Any other Value : Evaluates to itself
//
// returns object containing fields:
//
// match: boolean, indicates if Case was a match
//
// result: result of action applied
//
evaluate : function( object ) {
var match = this.predicate;
if ( match instanceof Function )
match = match( object );
if ( match ) {
if (this.action instanceof Function )
return this.match( this.action(object) );
if ( this.action instanceof Case )
return this.action.evaluate( object );
if ( this.action instanceof Array ) {
var decision;
var result;
for (var c = 0; c < this.action.length; c++ ) {
decision = this.action[c];
if ( decision instanceof Case ) {
result = decision.evaluate( object );
if (result.match)
return result;
} else throw("Array of Case expected");
}
return this.nomatch;
}
return this.match(this.action);
}
return this.nomatch;
}
};
If it is a really big tree, and especially if it is generated from data, you could treat the decision functions like data, using a functional approach. For example:
var decisionTree =
new Case( true, Array(
new Case ( function(n){ return n < 0; }, Math.sin ),
new Case ( function(n){ return n < 2; }, "0<= n < 2" ),
new Case ( true, "Greater than two " )));
decisionTree.evaluate(1); // evaluates to string "0<= n < 2"
decisionTree.evaluate(-Math.PI/2); // evaluates to -1
decisionTree.evaluate(5); // evaluates to string "Greater than two"
Using this implementation, you can arbitrarily nest your tree:
// Represents a predicate and corresponding action to take if predicate is a
// match.
//
// predicate : true or Function( object ) returning a boolean.
//
// action : One of Function, Case, Array of Cases or other value (see
// Case.evaluate as to how each is applied)
//
//
Case = function (predicate, action) {
this.predicate = predicate;
this.action = action;
};
Case.prototype = {
nomatch : { match : false },
match : function (v) { return { match : true, result :v }; },
// Recursively test Cases and applies corresponding action on
// `object`.
//
// The action applied depends on the datatype of `action`:
//
// - Function : evaluates to `action( object )`
//
// - Case : A subsequent test is performed. Evaluates to whatever
// the Cases action evaluates to.
//
// - Array of Cases : Subsequent tests are performed. Evaluates to whatever
// the action of the first matching Case evaluates to.
//
// - Any other Value : Evaluates to itself
//
// returns object containing fields:
//
// match: boolean, indicates if Case was a match
//
// result: result of action applied
//
evaluate : function( object ) {
var match = this.predicate;
if ( match instanceof Function )
match = match( object );
if ( match ) {
if (this.action instanceof Function )
return this.match( this.action(object) );
if ( this.action instanceof Case )
return this.action.evaluate( object );
if ( this.action instanceof Array ) {
var decision;
var result;
for (var c = 0; c < this.action.length; c++ ) {
decision = this.action[c];
if ( decision instanceof Case ) {
result = decision.evaluate( object );
if (result.match)
return result;
} else throw("Array of Case expected");
}
return this.nomatch;
}
return this.match(this.action);
}
return this.nomatch;
}
};
此类事情的最佳实践是以有意义的方式嵌套 if-then 语句，然后将它们放入自己的函数体中。一个函数不应有超过 2 个嵌套的 if；之后，可以在命名和实现良好的函数中放置进一步嵌套的 if ，从而抽象出程序的复杂性，同时保留其对在你离开后将阅读你的代码的程序员的意义。 :)
The best practice for this sort of thing is to nest if-then statements in a meaningful way, and then put them in their own function bodies. A function should never have more than 2 nested if's; after that, it is acceptable to put further nested if's in functions which are named and implemented well, thus abstracting the complexity of the program while retaining its meaning for the programmer who will read your code after you're gone. :)
发布评论
评论（2）
如果它是一棵非常大的树，特别是如果它是从数据生成的，则可以使用函数方法将决策函数视为数据。例如：
使用此实现，您可以任意嵌套您的树：
If it is a really big tree, and especially if it is generated from data, you could treat the decision functions like data, using a functional approach. For example:
Using this implementation, you can arbitrarily nest your tree:
此类事情的最佳实践是以有意义的方式嵌套 if-then 语句，然后将它们放入自己的函数体中。一个函数不应有超过 2 个嵌套的 if；之后，可以在命名和实现良好的函数中放置进一步嵌套的 if ，从而抽象出程序的复杂性，同时保留其对在你离开后将阅读你的代码的程序员的意义。 :)
The best practice for this sort of thing is to nest if-then statements in a meaningful way, and then put them in their own function bodies. A function should never have more than 2 nested if's; after that, it is acceptable to put further nested if's in functions which are named and implemented well, thus abstracting the complexity of the program while retaining its meaning for the programmer who will read your code after you're gone. :)