JavaScript extending the eval() function?

Question

I'm trying to make my own eval function in JavaScript, which will execute a string in the surrounding context, like eval, plus add a few more things.

So, in general, when doing:

eval("var foo = 8");
foo; // === 8

No problem; however, when I want to extend eval with my own function, like so:

function myEval(str) {
    return eval(str);
}
myEval("var foo = 8");
foo; //error, "foo" is not defined etc.....

And the obvious reason is because in myEval, the eval function called is only executed in that function's scope, not the surrounding scope.

I was wondering if its possible to execute eval in the scope it's surrounding function was called, in order to extend the JavaScript function eval?

No, there are only two scopes that `eval` can affect/be called in: The current scope or the global scope (via indirect `eval`). — Felix Kling, Apr 07 '20 at 21:49
Is this asked purely out of curiosity, or do you intend to actually use this? My respective comments on those situations are "hmm, I don't think so, but interesting question" and "why in God's name would you want to do this, or indeed touch `eval` in the first place?" — Robin Zigmond, Apr 07 '20 at 21:53
If you are using `eval` anyways, why don't you do a pattern of `eval(myEval(str))` instead? `myEval` can then produce arbitrary code executed in the current context, and prepend code, alter `str`, etc. (as others already mentioned though, eval = evil, but that's for you to decide) — ASDFGerte, Apr 07 '20 at 21:53
@VLAZ lol, this is in response to your answer, I was trying to bypass the problem of parameter passing, see other question's edit in a few seconds — B''H Bi'ezras -- Boruch Hashem, Apr 07 '20 at 21:55
@ASDFGerte that's kind of what was ended up being done, but yes that's a good idea (see answer) — B''H Bi'ezras -- Boruch Hashem, Apr 07 '20 at 21:56
@bluejayke: That's the indirect `eval` call I was talking about. The code passed to `eval` is evaluated in global scope. — Felix Kling, Apr 07 '20 at 22:09
@FelixKling Oh I didnt realize thats what u meant, cool then, I guess thats the answer — B''H Bi'ezras -- Boruch Hashem, Apr 07 '20 at 22:13
To be clear though, global scope is not the same as the scope that calls `myEval` (unless `myEval` is called from global scope of course). But if you want that, the implementation can just be `function myEval(str) { window.eval(str); }` — Felix Kling, Apr 07 '20 at 22:16
@FelixKling oh no, I mainly wanted it in the scope that calls it, not globa, but thanks tho — B''H Bi'ezras -- Boruch Hashem, Apr 07 '20 at 22:17
Or `function myEval(str) { (1, eval)(str); }` for that matter. But it's not what the question asks for. — ASDFGerte, Apr 07 '20 at 22:18
@ASDFGerte oh I realized that makes it executed on the global context as well, is there a way to only do it in the context it was called? — B''H Bi'ezras -- Boruch Hashem, Apr 07 '20 at 22:21
@ASDFGerte think again https://stackoverflow.com/a/40268022/2016831 — B''H Bi'ezras -- Boruch Hashem, Apr 08 '20 at 09:55
It's nice, that you are experimenting and learning, but i don't know why you feel the need to constantly claim it does something, which it doesn't. — ASDFGerte, Apr 08 '20 at 12:31
@ASDFGerte what do u mean? my main point is to be able to declare variables as an expression, not a statement, while using arguments, `so eval(str( \` var x `, ` x = args[0]; \` ))({hi:"there"}); console.log(x)` works — B''H Bi'ezras -- Boruch Hashem, Apr 08 '20 at 20:11

B''H Bi'ezras -- Boruch Hashem · Answer 1 · 2020-04-08T10:11:36.150

-1

Figured it out, just wrap the eval function in another function, and call that other function in the surrounding scope, like so:

function g(str) {
    return {
        eval,
        go(){
            this.eval(`
              //some other cool stuff
              let test = 1000;
              ${this.str}
            `)
        },
        str
    }
}
g("var pp = 3 * test").go()
console.log(pp);

EDIT:

this actually accomplishes it:

function str(cod1,cod2) {
    return `
        ${cod1};
        (function(...args) {
            ${cod2}
        })
    `
}

function scope1() {
  eval(str(
    `
      var x,
          y,
          z
    `,
    `
      x = args[0];
      y = args[1];
      z = args[2];

    `
  ))(1, {test(){return "ing"}}, {ok:"string"})
  console.log(x,y.test(),z, "scope1");
}

scope1();

try {
  console.log(x, y, z);
} catch(e) {
  console.log(e.toString());
}

edited Apr 08 '20 at 10:11

answered Apr 07 '20 at 21:54

B''H Bi'ezras -- Boruch Hashem

3,665
3
33
83

1

This just executes the code in the global context, it's an indirect eval call. It does not do what the question asks for. – ASDFGerte Apr 07 '20 at 22:01
@ASDFGerte the point of the question is to write a function that calls an more advanced, extended eval call, in the same context it was called. So instead of `eval("let k = 5; console.log(k)");` one could instead do, in that same context: `myEval(console.log(k))` with the `k` variable already defined, or many other variables already defined – B''H Bi'ezras -- Boruch Hashem Apr 07 '20 at 22:02
`(function f() { let k = 0; g('let k = "myValue";').go(); console.log(k); })();` – ASDFGerte Apr 07 '20 at 22:05
@ASDFGerte Whats the question? – B''H Bi'ezras -- Boruch Hashem Apr 07 '20 at 22:07

JavaScript extending the eval() function?

1 Answers1

Linked