欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

由eval(...) !== (1,eval)(...)引发的思考

程序员文章站 2022-07-08 20:21:15
...
先看一个例子
var x = 'outer';
(function() {
  var x = 'inner';
  eval('console.log("direct call: " + x)'); 
  (1,eval)('console.log("indirect call: " + x)'); 
})();

答案是:
direct call: inner
indirect call: outer



eval('1+1')是直接eval调用,而(1,eval)('1+1')不是。由于后者不是直接调用,因此它是间接eval调用。
(     1        ,         eval  )        ( '1+1' )
     |____|   |_____|    |_____|
       常量     操作符      标识符

     |_________________________|
      表达式

  |______________________________|
    主要表达式

  |______________________________|        |________|
   成员表达式                                参数

  |________________________________________________|
   调用表达式
在上面的例子里,很显然参数(调用括号)之前的哪部分不只是由“eval”标识符组成。这是一个完整的其他类型的表达式,由逗号操作符,数字常量,然后才是"eval"标识符组成。1,eval - 基于逗号操作符运行的方式-仍然执行一个标准的内置的eval函数,不过整个表达式不再是直接调用了。因此它是 间接eval调用。

(1, eval)('...')
(eval, eval)('...')
(1 ? eval : 0)('...')
(__ = eval)('...')
var e = eval; e('...')
(function(e) { e('...') })(eval)
(function(e) { return e })(eval)('...')
(function() { arguments[0]('...') })(eval)
this.eval('...')
this['eval']('...')
[eval][0]('...')
eval.call(this, '...')
eval('eval')('...')
依据ES5,所有这些都是间接调用,且 应当在全局范围内执行执行代码。你是否注意到ES5定义说明调用表达式的eval应当执行标准的、内置的函数?这意味着根据上下文内容eval('1+1')必定不是直接调用。仅仅当eval真正地(不是重写或者隐含地)引用了标准的、内置的函数的时候,调用才被认为是直接调用。
eval = (function(eval) {
    return function(expr) {
      return eval(expr);
    };
  })(eval);

  eval('1+1'); // 它看前来像直接调用,不过实际上是间接调用。
               // 这是因为`eval`解析为定制的函数,而不是标准的、内置的函数。


eval('...')
  (eval)('...')
  (((eval)))('...')
  (function() { return eval('...') })()
  eval('eval("...")')
  (function(eval) { return eval('...'); })(eval)
  with({ eval: eval }) eval('...')
  with(window) eval('...')
看前来相当的直白,难道不是吗?
不过等一下,为什么认为(eval)('...')和(((eval)))('...')是直接调用呢?当然,它们并不遵守我们前面所建立的特性 - 调用表达式内部的成员表达式内的有"eval"标识符。这儿到底发生什么呢?难道是eval两边的括号让它成为间接调用的吗?

这个有点微妙的问题的答案就在ES5直接调用定义的第一段里 - 是这样一个事实:调用表达式里的 "eval"应当是引用,而不是值。在程序执行期间,eval('1+1')表达式里的eval只不过是一个引用,而且需要计算出一个值。一旦计算完成,这个值(最可能)是标准的、内置的函数对象。在前面已经分析的(1,eval)('1+1')间接调用里所发生的是(1,eval)表达式计算出一个值,而不是一个引用。由于它计算出的
不是引用,所以不能认为它是直接eval调用。
但是(eval)('1+1')又如何呢?

认为(eval)是直接调用的原因是因为(eval)表达式仍然计算出的是一个引用,不是一个值。((eval)),(((eval)))等也是同样的。这种情况的出现是因为成组操作符-"("和")"-不能计算自身的表达式。如果传递引用给成组操作符-"("和")"-它仍然计算出一个引用,而不是一个值。

eval(); // <-- 调用括号左边的表达式 — "eval" — 计算出一个引用
  (eval)(); // <-- 调用括号左边的表达式 — "(eval)" — 计算出一个引用
  (((eval)))(); // <-- 调用括号左边的表达式 — "(((eval)))" — 计算出一个引用
  (1,eval)(); // <-- 调用括号左边的表达式 — "(1, eval)" — 计算出一个值
  (eval = eval)(); // <-- 调用括号左边的表达式 — "(eval = eval)" — 计算出一个值
如ECMAScript所说,这是因为两个操作符 - (例子(1,eval)里的)逗号操作符和(例子(eval=eval)里的)等号操作符-对它的操作数执行了GetValue。因此,(1,eval)和(eval = eval)计算出一个值,而eval 和 (eval)计算出的是一个引用。

现在希望已经弄清楚了(eval)('...')和(function(eval){ retuan eval('...')})(eval)是直接eval调用,而(1,eval)('...')和this.eval('...')不是直接调用的原因。