以下代码演示了引擎的功能：
const formula = "if( 1; round(10,2); 2*10)";
const formula1 = "round2(15.542 + 0.5)";
const formula2 = "max(2*15; 10; 20)";
const formula3 = "min(2; 10; 20)";
const formula4 = "round4(random()*10)";
const formula5 = "if ( max(0;10) ; 10*5 ; 15 ) ";
const formula6 = "sum(2*15; 10; 20)";
const calculator = new Calculator(null);
console.log(formula+" = "+calculator.calc(formula)); // if( 1; round(10,2); 2*10) = 10
console.log(formula1+" = "+calculator.calc(formula1)); // round2(15.542 + 0.5) = 16.04
console.log(formula2+" = "+calculator.calc(formula2)); // max(2*15; 10; 20) = 30
console.log(formula3+" = "+calculator.calc(formula3)); // min(2; 10; 20) = 2
console.log(formula4+" = "+calculator.calc(formula4)); // round4(random()*10) = 5.8235
console.log(formula5+" = "+calculator.calc(formula5)); // if ( max(0;10) ; 10*5 ; 15 ) = 50
console.log(formula6+" = "+calculator.calc(formula6)); // sum(2*15; 10; 20) = 60
在开始描述公式引擎的体系结构之前，应注意以下几点：
- 计算器对象作为参数可以采用Map形式的电子表格单元格的数据源，其中键是A1格式的单元格名称，值是单个令牌或令牌对象数组，在创建公式字符串时会将其解析为该字符串。在此示例中，公式中未使用任何单元格，因此数据源被指定为null。
- 函数以[function_name]（[argument1]; [argument2]; ...）的格式编写。
- 编写公式时不考虑空格-将公式字符串拆分为标记时，所有空白字符都将被预先删除。
- 数字的小数部分可以用点或逗号分隔-将公式字符串拆分为标记时，小数点将转换为点。
- 除以0得出0，因为在可能除以0的情况下进行应用计算时，该函数[if（除数！= 0;除数/除数; 0）]
您可以在Internet上找到很多有关波兰符号本身的资料，因此最好立即开始描述代码。对于式发动机本身的源代码在托管https://github.com/leossnet/bizcalc下在MIT许可/ JS /数据部分和包括所述calculator.js和token.js文件。您可以在bizcalc.ru上立即尝试使用计算器。
因此，让我们从集中在Types对象中的令牌类型开始：
const Types = {
Cell: "cell" ,
Number: "number" ,
Operator: "operator" ,
Function: "function",
LeftBracket: "left bracket" ,
RightBracket: "right bracket",
Semicolon: "semicolon",
Text: "text"
};
与标准引擎实现相比，添加了以下类型：
- 单元格：“单元格”是电子表格中单元格的名称，可以包含文本，数字或公式；
- 功能：“功能”-功能；
- 分号：“ semicolon”-函数参数分隔符，在这种情况下为“;”;
- 文本：“文本”-计算引擎忽略的文本。
与其他任何引擎一样，实现了对五个主要运算符的支持：
const Operators = {
["+"]: { priority: 1, calc: (a, b) => a + b }, //
["-"]: { priority: 1, calc: (a, b) => a - b }, //
["*"]: { priority: 2, calc: (a, b) => a * b }, //
["/"]: { priority: 2, calc: (a, b) => a / b }, //
["^"]: { priority: 3, calc: (a, b) => Math.pow(a, b) }, //
};
为了测试引擎，配置了以下功能（可以扩展功能列表）：
const Functions = {
["random"]: {priority: 4, calc: () => Math.random() }, //
["round"]: {priority: 4, calc: (a) => Math.round(a) }, //
["round1"]: {priority: 4, calc: (a) => Math.round(a * 10) / 10 },
["round2"]: {priority: 4, calc: (a) => Math.round(a * 100) / 100 },
["round3"]: {priority: 4, calc: (a) => Math.round(a * 1000) / 1000 },
["round4"]: {priority: 4, calc: (a) => Math.round(a * 10000) / 10000 },
["sum"]: {priority: 4, calc: (...args) => args.reduce( (sum, current) => sum + current, 0) },
["min"]: {priority: 4, calc: (...args) => Math.min(...args) },
["max"]: {priority: 4, calc: (...args) => Math.max(...args) },
["if"]: {priority: 4, calc: (...args) => args[0] ? args[1] : (args[2] ? args[2] : 0) }
};我认为以上代码可以说明一切。接下来，考虑令牌类的代码：
class Token {
// "+-*/^();""
static separators = Object.keys(Operators).join("")+"();";
// "[\+\-\*\/\^\(\)\;]"
static sepPattern = `[${Token.escape(Token.separators)}]`;
// "random|round|...|sum|min|max|if"
static funcPattern = new RegExp(`${Object.keys(Functions).join("|").toLowerCase()}`, "g");
#type;
#value;
#calc;
#priority;
/**
* , ,
*
*/
constructor(type, value){
this.#type = type;
this.#value = value;
if ( type === Types.Operator ) {
this.#calc = Operators[value].calc;
this.#priority = Operators[value].priority;
}
else if ( type === Types.Function ) {
this.#calc = Functions[value].calc;
this.#priority = Functions[value].priority;
}
}
/**
*
*/
/**
*
* @param {String} formula -
*/
static getTokens(formula){
let tokens = [];
let tokenCodes = formula.replace(/\s+/g, "") //
.replace(/(?<=\d+),(?=\d+)/g, ".") // ( )
.replace(/^\-/g, "0-") // 0 "-"
.replace(/\(\-/g, "(0-") // 0 "-"
.replace(new RegExp (Token.sepPattern, "g"), "&$&&") // &
.split("&") // &
.filter(item => item != ""); //
tokenCodes.forEach(function (tokenCode){
if ( tokenCode in Operators )
tokens.push( new Token ( Types.Operator, tokenCode ));
else if ( tokenCode === "(" )
tokens.push ( new Token ( Types.LeftBracket, tokenCode ));
else if ( tokenCode === ")" )
tokens.push ( new Token ( Types.RightBracket, tokenCode ));
else if ( tokenCode === ";" )
tokens.push ( new Token ( Types.Semicolon, tokenCode ));
else if ( tokenCode.toLowerCase().match( Token.funcPattern ) !== null )
tokens.push ( new Token ( Types.Function, tokenCode.toLowerCase() ));
else if ( tokenCode.match(/^\d+[.]?\d*/g) !== null )
tokens.push ( new Token ( Types.Number, Number(tokenCode) ));
else if ( tokenCode.match(/^[A-Z]+[0-9]+/g) !== null )
tokens.push ( new Token ( Types.Cell, tokenCode ));
});
return tokens;
}
/**
*
* @param {String} str
*/
static escape(str) {
return str.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
}
}Token类是一个容器，用于存储不可分割的文本单元，其中的一行公式被分解，每个公式都具有特定的功能。
Token类的构造函数将Types对象的字段中的标记类型作为参数，并将值（从公式字符串中提取的不可分割的文本单元）作为参数。
Token类的内部私有字段用于存储优先级值和求值表达式，并在构造函数中根据Operators和Functions对象的值进行定义。
作为一种辅助方法，实现了静态函数转义（str），该代码取自Internet上第一个找到的页面，转义了RegExp对象认为特殊的字符。
Token类中最重要的方法是getTokens静态函数，该函数解析公式字符串并返回Token对象的数组。该方法实现了一个小技巧-在拆分为令牌之前，将“＆”符号添加到分隔符（运算符和括号）中，该符号未在公式中使用，然后才拆分“＆”符号。
getTokens方法本身的实现是对所有接收到的令牌与模板进行循环比较，确定令牌类型，创建Token类的对象并将其添加到结果数组中。
这样就完成了准备计算的初步工作。下一步是计算本身，它们在Calculator类中实现：
class Calculator {
#tdata;
/**
*
* @param {Map} cells ,
*/
constructor(tableData) {
this.#tdata = tableData;
}
/**
*
* @param {Array|String} formula -
*/
calc(formula){
let tokens = Array.isArray(formula) ? formula : Token.getTokens(formula);
let operators = [];
let operands = [];
let funcs = [];
let params = new Map();
tokens.forEach( token => {
switch(token.type) {
case Types.Number :
operands.push(token);
break;
case Types.Cell :
if ( this.#tdata.isNumber(token.value) ) {
operands.push(this.#tdata.getNumberToken(token));
}
else if ( this.#tdata.isFormula(token.value) ) {
let formula = this.#tdata.getTokens(token.value);
operands.push(new Token(Types.Number, this.calc(formula)));
}
else {
operands.push(new Token(Types.Number, 0));
}
break;
case Types.Function :
funcs.push(token);
params.set(token, []);
operators.push(token);
break;
case Types.Semicolon :
this.calcExpression(operands, operators, 1);
//
let funcToken = operators[operators.length-2];
//
params.get(funcToken).push(operands.pop());
break;
case Types.Operator :
this.calcExpression(operands, operators, token.priority);
operators.push(token);
break;
case Types.LeftBracket :
operators.push(token);
break;
case Types.RightBracket :
this.calcExpression(operands, operators, 1);
operators.pop();
//
if (operators.length && operators[operators.length-1].type == Types.Function ) {
//
let funcToken = operators.pop();
//
let funcArgs = params.get(funcToken);
let paramValues = [];
if ( operands.length ) {
//
funcArgs.push(operands.pop());
//
paramValues = funcArgs.map( item => item.value );
}
//
operands.push(this.calcFunction(funcToken.calc, ...paramValues));
}
break;
}
});
this.calcExpression(operands, operators, 0);
return operands.pop().value;
}
/**
* ()
* @param {Array} operands
* @param {Array} operators
* @param {Number} minPriority
*/
calcExpression (operands, operators, minPriority) {
while ( operators.length && ( operators[operators.length-1].priority ) >= minPriority ) {
let rightOperand = operands.pop().value;
let leftOperand = operands.pop().value;
let operator = operators.pop();
let result = operator.calc(leftOperand, rightOperand);
if ( isNaN(result) || !isFinite(result) ) result = 0;
operands.push(new Token ( Types.Number, result ));
}
}
/**
*
* @param {T} func -
* @param {...Number} params -
*/
calcFunction(calc, ...params) {
return new Token(Types.Number, calc(...params));
}
}
与通常的公式引擎一样，所有计算都在主函数calc（公式）中执行，其中将公式字符串或现成的令牌数组作为参数传递。如果将公式字符串传递给calc方法，则会将其预先转换为令牌数组。
calcExpression方法用作辅助方法，该方法将操作数堆栈，运算符堆栈和最小运算符优先级作为参数来评估表达式。
作为常规公式引擎的扩展，实现了一个相当简单的函数calcFunction，该函数将函数名称作为参数以及该函数的任意数量的参数。 calcFunction计算公式函数的值，并返回具有数字类型的新Token对象。
为了在一般的计算周期内计算函数，将一个函数堆栈和一个用于函数参数的映射添加到操作数和运算符的堆栈中，其中键是函数的名称，而值是参数的数组。
最后，我将给出一个示例，说明如何以单元格及其值的散列形式使用数据源。首先，定义一个实现计算器使用的接口的类：
class Data {
#map;
//
constructor() {
this.#map = new Map();
}
//
add(cellName, number) {
this.#map.set(cellName, number);
}
// , , Calculator.calc()
isNumber(cellName) {
return true;
}
// , Calculator.calc()
getNumberToken (token) {
return new Token (Types.Number, this.#map.get(token.value) );
}
}好吧，那很简单。我们创建一个包含单元格值的数据源。然后，我们定义一个公式，其中操作数是单元格引用。最后，我们进行计算：
let data = new Data();
data.add("A1", 1);
data.add("A2", 1.5);
data.add("A3", 2);
let formula = "round1((A1+A2)^A3)";
let calculator = new Calculator(data);
console.log(formula+" = "+calculator.calc(formula)); // round1((A1+A2)^A3) = 6.3
感谢您的关注。