expressionify

Simple node.js expression parser and evaluator using shunting-yard and reverse polish notation algorithms.

Expressionify allow to define all operators in expression. Hash of operators must to contain objects with following fields:

• execute - function that evaluate operator action.

• priority - operator priority. The higher value the higher priority.

• type - operator type - 'unary' or 'binary'.

For example, boolean operators will represented as following hash:

var booleanOperators = {
    '|': {
        execute: function(x, y) { return x || y; },
        priority: 1,
        type: 'binary'
    },
    '&': {
        execute: function(x, y) { return x && y; },
        priority: 2,
        type: 'binary'
    },
    '!': {
        execute: function(x) { return !x; },
        priority: 3,
        type: 'unary'
    }
};

Also you must pass parseOperand to evaluate methods. parseOperand will be used to get value of every operand. Operand is a sequence of non-whitespace characters that is not equal to any operator or bracket.

Note: parseOperand must return value compatible with defined operators.

For example, see parseOperand for boolean expressions:

var parseBooleanOperand = function(operand) {
    if (operand === 'true' || operand === '1') {
        return true;
    } else {
        return false;
    }
};

API

expressionify exposes function which accepts following parameters:

• expression String

• params Object

• operators - hash of operators. Required.

• parseOperand - function that will be used to parse every operand.

Returns evaluator function which accepts same expression and params arguments, that allows to override parameters specified during evaluator creation.

Examples

For example, evaluating simple logic expressions using once built evaluator:

var evaluateExpression = expressionify({
    operators: booleanOperators,
    parseOperand: Number
});
 
var result = evaluateExpression('(1 | 0) & !0');
 
console.log(result);
// true
 
result = evaluateExpression('(1 | 0) & !1');
 
console.log(result);
// false

Another example is evaluating expression that contains variables:

var values = {
    x: true,
    y: false,
    z: false
};
 
var evaluateExpression = expressionify('(x | y) & !z', {
    operators: booleanOperators,
    parseOperand: function(operand) {
        return values[operand];
    }
});
 
console.log(evaluateExpression());
// true
 
values.z = true;
console.log(evaluateExpression());
// false

For more examples with boolean, arithmetical and set expressions see ./test directory.