Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/2do2go/expressionify
Simple node.js expression parser and evaluator using shunting-yard and reverse polish notation algorithms
https://github.com/2do2go/expressionify
Last synced: about 1 month ago
JSON representation
Simple node.js expression parser and evaluator using shunting-yard and reverse polish notation algorithms
- Host: GitHub
- URL: https://github.com/2do2go/expressionify
- Owner: 2do2go
- Created: 2016-07-20T11:36:33.000Z (over 8 years ago)
- Default Branch: master
- Last Pushed: 2016-08-15T07:11:10.000Z (over 8 years ago)
- Last Synced: 2024-11-29T04:48:35.949Z (about 2 months ago)
- Language: JavaScript
- Size: 21.5 KB
- Stars: 3
- Watchers: 5
- Forks: 1
- Open Issues: 1
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# expressionify
[](https://travis-ci.org/2do2go/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:
```js
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:
```js
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:
```js
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:
```js
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](./test).