Exemples de code détaillés sur la façon d'utiliser la fonction globale eval() en JavaScript

La détermination dynamique des chaînes dans le code source est une fonctionnalité de langage très puissante qu'il est presque inutile d'appliquer dans la pratique. Si vous utilisez eval(), vous devez soigneusement déterminer si vous en avez vraiment besoin.

1. eval() est-il une fonction ou un opérateur

eval() est une fonction, mais parce qu'elle a été considérée comme ? une opération que Fu est venu soigner. . Les premières versions du langage JavaScript définissaient la fonction eval, et les interpréteurs JavaScript modernes effectuent une analyse et une optimisation approfondies du code. Le problème avec eval est que le code utilisé pour l'exécution dynamique ne peut généralement pas être analysé. En d'autres termes, si une fonction appelle eval, l'interpréteur ne pourra pas optimiser davantage la fonction et définir eval comme une autre partie de la fonction. qu'il peut recevoir un autre nom, var f=eval ; alors l'interpréteur ne peut pas optimiser en toute sécurité une fonction qui appelle f(). Lorsque eval est un opérateur, ces problèmes peuvent être évités.

2. eval()

eval() n'a qu'un seul paramètre. Si le paramètre transmis n'est pas une chaîne, il renvoie directement cette fonction. Si le paramètre est une chaîne, il compilera la chaîne sous forme de code JavaScript et lèvera une exception d'erreur de syntaxe si la compilation échoue. Si la compilation réussit, ce morceau de code sera exécuté et la valeur de la dernière expression ou instruction de la chaîne sera renvoyée. Si la dernière expression ou instruction n'a pas de valeur, undefined sera finalement renvoyé. Si la chaîne lève une exception, cette exception transmettra l'appel à eval().

La chose la plus importante à propos de eval est qu'il utilise l'environnement à portée variable dans lequel il est appelé. Autrement dit, il recherche les valeurs des variables et définit de nouvelles variables et fonctions exactement de la même manière que le code dans la portée locale. Si une fonction définit une variable locale x puis appelle eval("x"), elle renvoie la valeur de la variable locale. S'il appelle eval("x=1"), il modifie la valeur de la variable locale. Si la fonction appelle eval("var y=2;"), elle déclare une nouvelle variable locale y. De même, une fonction peut déclarer une variable locale via le code suivant :

eval("function f() {return x+1;}”);

Si eval est appelé dans le code de niveau supérieur, bien sûr, il agira sur les variables globales et les fonctions globales.

Il convient de noter que la chaîne passée à eval doit être grammaticalement cohérente. Vous ne pouvez pas coller des extraits de code arbitraires dans la fonction via eval. Par exemple : eval("return ;") n'a aucun sens car return joue uniquement. un rôle au sein d'une fonction, et en fait, le contexte dans lequel la chaîne d'eval est exécutée est le même que le contexte dans lequel la fonction est appelée, cela ne lui permet pas de s'exécuter dans le cadre de la fonction. Si la chaîne est sémantique en tant que script séparé, alors il n'y a aucun problème à la transmettre à eval en tant que paramètre, sinon eval lèvera une exception d'erreur de syntaxe.

3. Global eval()

eval() a la capacité de modifier les variables de mise en page, ce qui est un gros problème pour les optimiseurs JavaScript. Cependant, à titre provisoire, l'interpréteur JavaScript n'optimise pas beaucoup les fonctions qui appellent eval. Mais comment fonctionne l'interpréteur JavaScript lorsqu'un script définit un alias pour eval et l'appelle sous un autre nom ? Afin de simplifier l'implémentation des interpréteurs JavaScript, le standard ECMAScript3 stipule qu'aucun interpréteur n'est autorisé à attribuer des alias à eval. Si la fonction eval est appelée via un alias, une exception EavlError sera levée.

En fait, la plupart des implémentations ne le font pas. Lorsqu'il est appelé via un alias, eval exécutera sa chaîne en tant que code global de niveau supérieur. Le code exécuté peut définir de nouvelles variables globales et fonctions globales, ou attribuer des valeurs aux variables globales, mais il ne peut pas utiliser ou modifier les variables locales dans la fonction appelante. Par conséquent, cela n'affectera pas l'optimisation du code au sein de la fonction.

ECMAScript5 est contre l'utilisation d'EavlError et standardise le comportement de eval, "direct eval". Lorsque la fonction eval() est appelée directement en utilisant le nom "eval" non qualifié, elle est généralement appelée "direct eval". ". Lorsque eval() est appelé directement, il est toujours exécuté dans le cadre du contexte dans lequel il est appelé. D'autres appels indirects utilisent l'objet global comme portée de contexte et ne peuvent pas lire, écrire ou définir des variables et fonctions locales. Voici un exemple de code :

var geval=eval;                //使用别名调用evla将是全局eval
var x="global",y="global";    //两个全局变量
function f(){                //函数内执行的是局部eval
    var x="local";            //定义局部变量
    eval("x += ' chenged';");//直接使用eval改变的局部变量的值
    return x;                //返回更改后的局部变量
}
Function g(){                //这个函数内执行了全局eval
    var y="local";
    geval("y += ' changed';"); //直接调用改变了全局变量的值
    return y;
}
console.log(f(),x);            //改变了布局变了，输出 “local changed global”
console.log(g(),y);            //改变了全局变量，输出    “local global changed”

Ces comportements d'évaluation globale ne sont pas seulement un compromis fait pour le besoin d'optimisation du code, c'est en fait une fonctionnalité très utile. Ils nous permettent d'exécuter des extraits de script globaux sans. toute dépendance au contexte. Il existe très peu de scénarios dans lesquels eval est réellement nécessaire pour exécuter un segment de code. Mais lorsque vous réalisez réellement sa nécessité, vous êtes plus susceptible d'utiliser l'évaluation globale plutôt que l'évaluation locale.

4. Évaluation stricte()

Le mode strict ECMAScript5 impose plus de restrictions sur le comportement de la fonction eval() et même sur l'utilisation de l'identifiant eval. Lorsque eval est appelé en mode strict, ou que le segment de code exécuté par eval commence par une directive "Use strict", eval est ici un eval local dans le contexte privé. Autrement dit, en mode strict, le segment de code exécuté par eval peut interroger ou modifier des variables locales, mais ne peut pas définir de nouvelles variables ou fonctions dans la portée locale.

De plus, le mode strict répertorie "eval" comme mot réservé, ce qui fait que eval() ressemble davantage à un opérateur. La fonction eval() ne peut pas être remplacée par un alias. Et les noms de variables, les noms de fonctions. Ni les paramètres de fonction ni les paramètres de capture d'exception ne peuvent être nommés eval.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!