小编这次要给大家分享的是怎么编写一个javascript元循环求值器，文章内容丰富，感兴趣的小伙伴可以来了解一下，希望大家阅读完这篇文章之后能够有所收获。
创新互联主营察布查尔锡伯网站建设的网络公司,主营网站建设方案,重庆App定制开发,察布查尔锡伯h5成都微信小程序搭建,察布查尔锡伯网站营销推广欢迎察布查尔锡伯等地区企业咨询
结构
一个元循环求值器，完整的应该包含以下内容：
代码目录
根据结构看，我将代码目录大致拆分为以下几个文件
tokenizer和parser这两个过程不是本文的重点，我统一放在了parser中，交由 @babel/parser 来处理。
evaluate和apply这两个过程我统一放在了eval文件中处理，一会我们重点看下这部分。
scope则放入scope文件。
evaluate-apply
这其实是一个递归计算的过程。
首先，evaluate 接收两个参数，node 当前遍历的AST树节点和 scope 当前环境。然后，evaluate去根据 node 的 type 属性，判断该节点是什么类型。判断出类型后，执行 apply 去求值这个节点所代表的表达式。apply 中会再次递归的执行 evaluate 去计算当前节点的子节点。最终，执行完整颗AST树。
我们来看下具体代码吧
const evaluate = (node: t.Node, scope) => {
const evalFunc = evaluateMap[node.type];
if (!evalFunc) {
throw `${node.loc} ${node.type} 还未实现`;
}
return evalFunc(node, scope);
}以上就是evaluate具体做的事。
其中，evaluateMap 是目前实现的内容集合，我们来看下具体的代码
const evaluateMap: EvaluateMap = {
File(node: t.File, scope) {
evaluate(node.program, scope);
},
Program(node: t.Program, scope) {
for (const n of node.body) {
evaluate(n, scope);
}
},
Identifier(node: t.Identifier, scope) {
const $var = scope.$find(node.name);
if (!$var) {
throw `[Error] ${node.loc}, '${node.name}' 未定义`;
}
return $var.$get();
},
StringLiteral(node: t.StringLiteral, scope) {
return node.value;
},
NumericLiteral(node: t.NumericLiteral, scope) {
return node.value;
},
BooleanLiteral(node: t.BooleanLiteral, scope) {
return node.value;
},
NullLiteral(node: t.NullLiteral, scope) {
return null;
},
BlockStatement(block: t.BlockStatement, scope) {
const blockScope = scope.shared ? scope : new Scope('block', scope);
for (const node of block.body) {
const res = evaluate(node, blockScope);
if (res === BREAK || res === CONTINUE || res === RETURN) {
return res;
}
}
},
DebuggerStatement(node: t.DebuggerStatement, scope) {
debugger;
},
ExpressionStatement(node: t.ExpressionStatement, scope) {
evaluate(node.expression, scope);
},
ReturnStatement(node: t.ReturnStatement, scope) {
RETURN.result = (node.argument ? evaluate(node.argument, scope) : void 0);
return RETURN;
},
BreakStatement(node: t.BreakStatement, scope) {
return BREAK;
},
ContinueStatement(node: t.ContinueStatement, scope) {
return CONTINUE;
},
IfStatement(node: t.IfStatement, scope) {
if (evaluate(node.test, scope)) {
return evaluate(node.consequent, scope);
}
if (node.alternate) {
const ifScope = new Scope('block', scope, true);
return evaluate(node.alternate, ifScope)
}
},
SwitchStatement(node: t.SwitchStatement, scope) {
const discriminant = evaluate(node.discriminant, scope);
const switchScope = new Scope('switch', scope);
for (const ca of node.cases){
if (ca.test === null || evaluate(ca.test, switchScope) === discriminant) {
const res = evaluate(ca, switchScope);
if (res === BREAK) {
break;
} else if (res === RETURN) {
return res;
}
}
}
},
SwitchCase(node: t.SwitchCase, scope) {
for (const item of node.consequent) {
const res = evaluate(item, scope);
if (res === BREAK || res === RETURN) {
return res;
}
}
},
ThrowStatement(node: t.ThrowStatement, scope) {
throw evaluate(node.argument, scope);
},
TryStatement(node: t.TryStatement, scope) {
try {
return evaluate(node.block, scope);
} catch (error) {
if (node.handler) {
const catchScope = new Scope('block', scope, true);
catchScope.$let((node.handler.param).name, error);
return evaluate(node.handler, catchScope);
} else {
throw error;
}
} finally {
if (node.finalizer) {
return evaluate(node.finalizer, scope);
}
}
},
CatchClause(node: t.CatchClause, scope) {
return evaluate(node.body, scope);
},
WhileStatement(node: t.WhileStatement, scope) {
while (evaluate(node.test, scope)) {
const whileScope = new Scope('loop', scope, true);
const res = evaluate(node.body, whileScope);
if (res === CONTINUE) continue;
if (res === BREAK) break;
if (res === RETURN) return res;
}
},
ForStatement(node: t.ForStatement, scope) {
for (
const forScope = new Scope('loop', scope),
initVal = evaluate(node.init, forScope);
evaluate(node.test, forScope);
evaluate(node.update, forScope)
) {
const res = evaluate(node.body, forScope);
if (res === CONTINUE) continue;
if (res === BREAK) break;
if (res === RETURN) return res;
}
},
ForInStatement(node: t.ForInStatement, scope) {
const kind = (node.left).kind;
const decl = (node.left).declarations[0];
const name = (decl.id).name;
for (const value in evaluate(node.right, scope)) {
const forScope = new Scope('loop', scope, true);
scope.$define(kind, name, value);
const res = evaluate(node.body, forScope);
if (res === CONTINUE) continue;
if (res === BREAK) break;
if (res === RETURN) return res;
}
},
ForOfStatement(node: t.ForOfStatement, scope) {
const kind = (node.left).kind;
const decl = (node.left).declarations[0];
const name = (decl.id).name;
for (const value of evaluate(node.right, scope)) {
const forScope = new Scope('loop', scope, true);
scope.$define(kind, name, value);
const res = evaluate(node.body, forScope);
if (res === CONTINUE) continue;
if (res === BREAK) break;
if (res === RETURN) return res;
}
},
FunctionDeclaration(node: t.FunctionDeclaration, scope) {
const func = evaluateMap.FunctionExpression(node, scope);
scope.$var(node.id.name, func);
},
VariableDeclaration(node: t.VariableDeclaration, scope) {
const { kind, declarations } = node;
for (const decl of declarations) {
const varName = (decl.id).name;
const value = decl.init ? evaluate(decl.init, scope) : void 0;
if (!scope.$define(kind, varName, value)) {
throw `[Error] ${name} 重复定义`
}
}
},
ThisExpression(node: t.ThisExpression, scope) {
const _this = scope.$find('this');
return _this ? _this.$get() : null;
},
ArrayExpression(node: t.ArrayExpression, scope) {
return node.elements.map(item => evaluate(item, scope));
},
ObjectExpression(node: t.ObjectExpression, scope) {
let res = Object.create(null);
node.properties.forEach((prop) => {
let key;
let value;
if(prop.type === 'ObjectProperty'){
key = prop.key.name;
value = evaluate(prop.value, scope);
res[key] = value;
}else if (prop.type === 'ObjectMethod'){
const kind = prop.kind;
key = prop.key.name;
value = evaluate(prop.body, scope);
if(kind === 'method') {
res[key] = value;
}else if(kind === 'get') {
Object.defineProperty(res, key, { get: value });
}else if(kind === 'set') {
Object.defineProperty(res, key, { set: value });
}
}else if(prop.type === 'SpreadElement'){
const arg = evaluate(prop.argument, scope);
res = Object.assign(res, arg);
}
});
return res;
},
FunctionExpression(node: t.FunctionExpression, scope) {
return function (...args: any) {
const funcScope = new Scope('function', scope, true);
node.params.forEach((param: t.Identifier, idx) => {
const { name: paramName } = param;
funcScope.$let(paramName, args[idx]);
});
funcScope.$const('this', this);
funcScope.$const('arguments', arguments);
const res = evaluate(node.body, funcScope);
if (res === RETURN) {
return res.result;
}
}
},
ArrowFunctionExpression(node: t.ArrowFunctionExpression, scope) {
return (...args) => {
const funcScope = new Scope('function', scope, true);
node.params.forEach((param: t.Identifier, idx) => {
const { name: paramName } = param;
funcScope.$let(paramName, args[idx]);
});
const _this = funcScope.$find('this');
funcScope.$const('this', _this ? _this.$get() : null);
funcScope.$const('arguments', args);
const res = evaluate(node.body, funcScope);
if (res === RETURN) {
return res.result;
}
}
},
UnaryExpression(node: t.UnaryExpression, scope) {
const expressionMap = {
'~': () => ~evaluate(node.argument, scope),
'+': () => +evaluate(node.argument, scope),
'-': () => -evaluate(node.argument, scope),
'!': () => !evaluate(node.argument, scope),
'void': () => void evaluate(node.argument, scope),
'typeof': () => {
if (node.argument.type === 'Identifier') {
const $var = scope.$find(node.argument.name);
const value = $var ? $var.$get() : void 0;
return typeof value;
}
return typeof evaluate(node.argument, scope);
},
'delete': () => {
if (node.argument.type === 'MemberExpression') {
const { object, property, computed } = node.argument;
const obj = evaluate(object, scope);
let prop;
if (computed) {
prop = evaluate(property, scope);
} else {
prop = property.name;
}
return delete obj[prop];
} else {
throw '[Error] 出现错误'
}
},
}
return expressionMap[node.operator]();
},
UpdateExpression(node: t.UpdateExpression, scope) {
const { prefix, argument, operator } = node;
let $var: IVariable;
if (argument.type === 'Identifier') {
$var = scope.$find(argument.name);
if (!$var) throw `${argument.name} 未定义`;
} else if (argument.type === 'MemberExpression') {
const obj = evaluate(argument.object, scope);
let prop;
if (argument.computed) {
prop = evaluate(argument.property, scope);
} else {
prop = argument.property.name;
}
$var = {
$set(value: any) {
obj[prop] = value;
return true;
},
$get() {
return obj[prop];
}
}
} else {
throw '[Error] 出现错误'
}
const expressionMap = {
'++': v => {
$var.$set(v + 1);
return prefix ? ++v : v++
},
'--': v => {
$var.$set(v - 1);
return prefix ? --v : v--
},
}
return expressionMap[operator]($var.$get());
},
BinaryExpression(node: t.BinaryExpression, scope) {
const { left, operator, right } = node;
const expressionMap = {
'==': (a, b) => a == b,
'===': (a, b) => a === b,
'>': (a, b) => a > b,
'<': (a, b) => a < b,
'!=': (a, b) => a != b,
'!==': (a, b) => a !== b,
'>=': (a, b) => a >= b,
'<=': (a, b) => a <= b,
'<<': (a, b) => a << b,
'>>': (a, b) => a >> b,
'>>>': (a, b) => a >>> b,
'+': (a, b) => a + b,
'-': (a, b) => a - b,
'*': (a, b) => a * b,
'/': (a, b) => a / b,
'&': (a, b) => a & b,
'%': (a, b) => a % b,
'|': (a, b) => a | b,
'^': (a, b) => a ^ b,
'in': (a, b) => a in b,
'instanceof': (a, b) => a instanceof b,
}
return expressionMap[operator](evaluate(left, scope), evaluate(right, scope));
},
AssignmentExpression(node: t.AssignmentExpression, scope) {
const { left, right, operator } = node;
let $var: IVariable;
if (left.type === 'Identifier') {
$var = scope.$find(left.name);
if(!$var) throw `${left.name} 未定义`;
} else if (left.type === 'MemberExpression') {
const obj = evaluate(left.object, scope);
let prop;
if (left.computed) {
prop = evaluate(left.property, scope);
} else {
prop = left.property.name;
}
$var = {
$set(value: any) {
obj[prop] = value;
return true;
},
$get() {
return obj[prop];
}
}
} else {
throw '[Error] 出现错误'
}
const expressionMap = {
'=': v => { $var.$set(v); return $var.$get() },
'+=': v => { $var.$set($var.$get() + v); return $var.$get() },
'-=': v => { $var.$set($var.$get() - v); return $var.$get() },
'*=': v => { $var.$set($var.$get() * v); return $var.$get() },
'/=': v => { $var.$set($var.$get() / v); return $var.$get() },
'%=': v => { $var.$set($var.$get() % v); return $var.$get() },
'<<=': v => { $var.$set($var.$get() << v); return $var.$get() },
'>>=': v => { $var.$set($var.$get() >> v); return $var.$get() },
'>>>=': v => { $var.$set($var.$get() >>> v); return $var.$get() },
'|=': v => { $var.$set($var.$get() | v); return $var.$get() },
'&=': v => { $var.$set($var.$get() & v); return $var.$get() },
'^=': v => { $var.$set($var.$get() ^ v); return $var.$get() },
}
return expressionMap[operator](evaluate(right, scope));
},
LogicalExpression(node: t.LogicalExpression, scope) {
const { left, right, operator } = node;
const expressionMap = {
'&&': () => evaluate(left, scope) && evaluate(right, scope),
'||': () => evaluate(left, scope) || evaluate(right, scope),
}
return expressionMap[operator]();
},
MemberExpression(node: t.MemberExpression, scope) {
const { object, property, computed } = node;
const obj = evaluate(object, scope);
let prop;
if (computed) {
prop = evaluate(property, scope);
} else {
prop = property.name;
}
return obj[prop];
},
ConditionalExpression(node: t.ConditionalExpression, scope) {
const { test, consequent, alternate } = node;
return evaluate(test, scope) ? evaluate(consequent, scope) : evaluate(alternate, scope);
},
CallExpression(node: t.CallExpression, scope) {
const func = evaluate(node.callee, scope);
const args = node.arguments.map(arg => evaluate(arg, scope));
let _this;
if (node.callee.type === 'MemberExpression') {
_this = evaluate(node.callee.object, scope);
} else {
const $var = scope.$find('this');
_this = $var ? $var.$get() : null;
}
return func.apply(_this, args);
},
NewExpression(node: t.NewExpression, scope) {
const func = evaluate(node.callee, scope);
const args = node.arguments.map(arg => evaluate(arg, scope));
return new (func.bind(func, ...args));
},
SequenceExpression(node: t.SequenceExpression, scope) {
let last;
node.expressions.forEach(expr => {
last = evaluate(expr, scope);
})
return last;
},
} 以上，evaluate-apply 这个过程就完了。
scope
我们再来看下 scope 该如何实现。
class Scope implements IScope {
public readonly variables: EmptyObj = Object.create(null);
constructor(
private readonly scopeType: ScopeType,
private parent: Scope = null,
public readonly shared = false,
) { }
}我们构造一个类来模拟 scope。可以看到，Scope 类包含了以下4个属性：
接下来我们看下该如何在环境中声明变量
首先构造一个类来模拟变量
class Variable implements IVariable {
constructor(
private kind: Kind,
private value: any
){ }
$get() {
return this.value
}
$set(value: any) {
if (this.kind === 'const') {
return false
}
this.value = value;
return true;
}
}这个类中有两个属性和两个方法
有了 Variable 类之后，我们就可以编写 Scope 类中的声明变量的方法了。
let 和 const 的声明方式基本一样
$const(varName: string, value: any) {
const variable = this.variables[varName];
if (!variable) {
this.variables[varName] = new Variable('const', value);
return true;
}
return false;
}
$let(varName: string, value: any) {
const variable = this.variables[varName];
if (!variable) {
this.variables[varName] = new Variable('let', value);
return true;
}
return false;
}var 的声明方式稍微有一点差异，因为js中，除了在 function 中，用var 声明的变量是会被声明到父级作用域的（js的历史遗留坑）。我们看下代码
$var(varName: string, value: any) {
let scope: Scope = this;
while (!!scope.parent && scope.scopeType !== 'function') {
scope = scope.parent;
}
const variable = scope.variables[varName];
if (!variable) {
scope.variables[varName] = new Variable('var', value);
} else {
scope.variables[varName] = variable.$set(value);
}
return true
}除了声明，我们还需要一个寻找变量的方法，该方法会从当前环境开始，一直沿着作用域链，找到最外层的环境为止。因此，代码实现如下
$find(varName: string): null | IVariable {
if (Reflect.has(this.variables, varName)) {
return Reflect.get(this.variables, varName);
}
if (this.parent) {
return this.parent.$find(varName);
}
return null;
}以上，一个基本的javascript元循环求值器就完成了
看完这篇关于怎么编写一个javascript元循环求值器的文章，如果觉得文章内容写得不错的话，可以把它分享出去给更多人看到。
