Question

美好的一天。我需要在某些对象上下文中使用eval表达式，但我找到的唯一解决方案是为每个对象函数创建存根：

 var c = {
    a : function () {
      return 'a';
    },
    b : function () {
      return 'b';
    }
  };

  function evalInObj(c, js) {
    function a() {
      return c.a();
    }

    function b() {
      return c.b();
    }

    return eval(js);
  };

  console.log(evalInObj(c, 'a() + b()'));

请告诉我正确的方法。我可以用原型来做吗？

  var C = function(id) {
    this.id = id;
  }

  C.prototype.a = function () {
    return 'a' + this.id;
  }

  C.prototype.b = function () {
    return 'b' + this.id;
  }

  function evalCtx(js) {
    console.log(this);  // C {id: 1}
    return eval(js);
  }

  var c1 = new C(1);
  evalCtx.call(c1, 'a() + b()'); // error: a is not defined

Answer 1

(() =>
{
    // 'use strict';
    function run(expression, context = {})
    {
        return function ()
        {
            return eval(expression);
        }.call(context);
    }

    let context = {a:{b:'Bb'}};
    console.log(run('this', context));      // {a:{b:'Bb'}}
    console.log(run('this.a', context));    // {b:'Bb'}
    console.log(run('this.a.b', context));  // 'Bb'
    console.log(run('a.b', context));       // ReferenceError: a is not defined
})();

Answer 2

此技术最显着的优势在于它不使用with关键字

因此即使在strict模式

+function()
{
    // jsut pollyfills for backward browsers...
    Object.prototype.keys || (Object.defineProperty(Object.prototype, 'keys', {value: function ()
        {
            var result = []; for (var key in this) result.push(key); return result;
        }}));
    Object.prototype.entries || (Object.defineProperty(Object.prototype, 'entries', {value: function ()
        {
            var result = []; for (var key in this) result.push([key, this[key]]); return result;
        }}));


    // here the magic...
    function run(expression, context)
    {
        var variables = {};
        (context instanceof Object) && context.entries().forEach(function(entry)
        {
            entry[0].match(/^[a-z_$][a-z0-9_$]*$/) && (variables[entry[0]] = entry[1]);
        });
        return (new Function('return function(' + variables.keys().join(', ') + ') { return ' + expression + '; }'))()// first get the synthetic function
               .apply(context, variables.entries().map(function(entry) { return entry[1]; }));
    }

    var output = run("a + '#' + b", {a: 'Aa', b: 'Bb', 0: 'Zero'});
    console.log(output); // Aa#Bb
}();

Answer 3

function runScript(ctx, js){ with(ctx){ return eval(js); }}

封闭。谢谢所有

我可以在对象上下文中评估表达式吗？

3 个答案: