Introduction to the use of eval() function in JavaScript_javascript skills

In JavaScript, you can use the eval() function to parse the JavaScript code in the string and return the corresponding code execution result:

Copy code The code is as follows:

console.log(eval("42 * 2"));//84

Essentially, eval() is a function of the JavaScript global object. For example, the above code is equivalent to:

Copy code The code is as follows:

console.log(this.eval("42 * 2"));//84

However, when using the eval() statement, the first method above is generally adopted, that is, ignoring the global object and using eval() directly.

Usage of eval()

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

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.

Return value of eval()

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

1. If the parameter of eval() is not a string, then eval() will return the parameter directly.
2. If the parameter of eval() is a string, then eval() parses the string into code and executes it, and returns 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().

Copy code The code is as follows:

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 can also expose the newly created variables in the parameter string code to external code. That is, if the eval() parameter string can be parsed legally, then JS will replace the line where eval() is located with the parsed code:

Copy code The code is as follows:

//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 realizing the above features is that 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:

Copy code The code is as follows:

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

If the eval() function is used 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":

Copy code The code is as follows:

//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. In IE6, 7, and 8, even if the eval() function is renamed, the "local variable environment" is still used.