编写一个javascript元循环求值器的方法

const evaluate = (node: t.node, scope) => {
 const evalfunc = evaluatemap[node.type];
 if (!evalfunc) {
 throw `${node.loc} ${node.type} 还未实现`;
 }
 return evalfunc(node, scope);
}

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((<t.identifier>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 = (<t.variabledeclaration>node.left).kind;
 const decl = (<t.variabledeclaration>node.left).declarations[0];
 const name = (<t.identifier>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 = (<t.variabledeclaration>node.left).kind;
 const decl = (<t.variabledeclaration>node.left).declarations[0];
 const name = (<t.identifier>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 = (<t.identifier>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;
 },
}

class scope implements iscope {
 public readonly variables: emptyobj = object.create(null);

 constructor(
 private readonly scopetype: scopetype,
 private parent: scope = null,
 public readonly shared = false,
 ) { }
}

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;
 }
}

$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(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;
}