Detailed explanation of eval() function return value and variable environment usage examples in JavaScript

Use of eval()

Based on the following two reasons, unless it is really necessary, you should try to avoid using the eval() statement in your code:

1 .Logically speaking, strings should be used to store content and information during program running, and should not be used to store specific calculation logic.
2. Since the eval() parameter is a string, and a string cannot be lexically processed, the JavaScript interpreter cannot optimize the eval() call statement.

The return value of eval()

The return value of eval() follows the following rules:

1. If the parameter of eval() is not a character string, then eval() will return the parameter directly.
2. If the parameter of eval() is a string, then eval() will parse the string into code and execute it, and return the result of the last line of code execution.
3. If the string cannot be parsed into legal code, eval() will throw a SyntaxError.
4. If the string can be parsed into legal code, but an error is reported during the execution of this code, then the error will be reported to the eval() statement and thrown by eval().

console.log(eval([1,2,3]));//[1, 2, 3]
console.log(typeof eval([1,2,3]));//object
console.log(eval("42 */ 2"));//SyntaxError
console.log(eval("42 * 2; 22 * 3;"));//66. eval returns the result of last expression/statement
console.log(eval("null.toString()"));//TypeError, exception in eval-ed code will be propagated outside eval().

Variable environment

eval() in JavaScript has an important feature: the code in the eval() parameter string can access variables in external code, and at the same time You can also expose newly created variables in parameter string code to external code. That is, if the eval() parameter string can be legally parsed, then JS will replace the line where eval() is located with the parsed code:

//variable environment
var a = 108;
console.log(eval("function double(x){return x*2;} a = double(a)"));
console.log(a);//216
console.log(double(33));//66

It is worth noting that the prerequisite for achieving the above features is The code in the eval() parameter string can be legally parsed. In addition to the correct syntax of the code, JS also requires that the code in the eval() parameter string must be "self-contained": the code must be meaningful only as far as the code in the parameter string is concerned. For example, you cannot pass a string such as "return;" to the eval() function:

function test(){
  var s = "test";
  eval("return s;");
}
test();//SyntaxError: return not in function

If you use the eval() function directly, the variables accessed by the code in the eval() parameter string are Those variables of the function where the eval() statement is located, that is, the variable environment used by the eval() function is the "local variable environment". If you do not use the eval() function directly, but use a new variable that also points to the eval() function, then the variables accessed by the code in the corresponding parameter string are global variables, that is, the variables used by the eval() function. The environment is the "global variable environment":

//local variable environment and global variable environment
var renamed = eval;
var x = "origin", y = "origin";
function f(){
  var x = "new";
  eval("x += 'Changed';");
  return x;
}
function g(){
  var y = "new";
  renamed("y += 'Changed';");
  return y;
}
console.log(f(), x);//newChanged origin
console.log(g(), y);//new originChanged

However, it is worth noting that the behavior in IE6, 7, and 8 is different from this. In IE6, 7, and 8, even if the eval() function is renamed, the "local variable environment" is still used.

The above is the detailed content of Detailed explanation of eval() function return value and variable environment usage examples in JavaScript. For more information, please follow other related articles on the PHP Chinese website!