Pré-analyse JavaScript et compétences associées Compétences d'analyse_javascript

Cet article décrit la pré-analyse JavaScript et les techniques associées avec des exemples. Partagez-le avec tout le monde pour votre référence, les détails sont les suivants :

Variable

De même, commencez par les conseils de comparaison d'erreurs de ces deux petits exemples.

alert(y1);     //代码段1
var y1 = 'dddd';
alert(y2);     //代码段2 // alert(typeof y2);
y2 = 'xxxxx';

Pensez-y d'abord, pourquoi l'un demande undéfini et l'autre renvoie une erreur de variable non définie. . Examinons d'abord le processus d'analyse JavaScript.

Javascript effectuera un événement de « pré-analyse » avant d'exécuter le processus. Le moteur d'analyse effectuera la création de toutes les variables var au niveau du bloc et leur donnera une valeur initiale : indéfinie. De cette façon, il est évident pourquoi undefined apparaît dans le premier exemple.

Donc, le premier morceau de code est en fait équivalent à

var y1;
alert(typeof y1); //很自然，它此时值为undefined
y1 = 'dddd';

Alors pourquoi le deuxième morceau de code renvoie-t-il à nouveau une erreur ? Il n'est plus à l'étape de "pré-analyse". (Ici, je suppose que le navigateur ne fait que deux choses lorsqu'il rencontre une balise de script : la pré-analyse. et exécution., en fait, ce ne sont pas seulement ces deux choses), mais dans la phase d'exécution, la raison pour laquelle l'erreur est générée est que js ne connaît pas l'état de y2 dans l'état de la section d'exécution (l'étape de pré-analyse). ne capture aucune information sur y2), bien sûr, une erreur non définie est renvoyée. Cela implique un autre problème : js est un langage faiblement typé et les variables peuvent être utilisées sans être définies, alors pourquoi une erreur de définition est-elle générée ici ?

Tout arrive pour une raison. JavaScript a toujours de nombreuses caractéristiques étranges, telles que la lecture et l'écriture inégales des variables. Les variables non définies sont uniquement accessibles en écriture et non en lecture. Qu'est-ce qui est inscriptible ? Tout le monde connaît cette façon d'écrire :

y2 = 'exam';  
//在没出现它的定义操作之前（即在它还没有自己的scope之前）该操作会将这段代码认为是定义一个全局变量，在window上注册一个属性y2，并赋值为exam

Mais en le lisant, le moteur js ne trouve aucune information pertinente à son sujet, il agit donc selon son propre tempérament et renvoie une erreur indéfinie sans pitié. C'est la règle du jeu de js. Et pourtant, pourquoi pouvons-nous obtenir son type ? Rappelez-vous comment js fonctionne sur les objets. Si vous accédez à une propriété et à un type d'objet inexistants, vous serez invité à indiquer undefined (car il s'agit actuellement d'une propriété de l'objet window).

Autre remarque : une distinction doit être faite ici. La lecture et l'écriture des variables ne sont pas égales. Elle n'est utilisée que pour les variables. Cette fonctionnalité n'existe pas. , cela affichera une invite indéfinie.

Conclusion

Voici le résultat de ma réflexion : il existe certaines similitudes entre les opérations d'écriture de variables et d'objets. Cependant, chacune a son propre ensemble de règles pour les opérations de lecture. De ce fait, le problème ci-dessus se pose.
De cette façon, il devrait être facile d’obtenir la réponse à la question suivante.

if (!('a' in window)) {
  var a = 1;
}
alert(a);

Fonction

Par extension, fonction. Rappelez-vous la pré-analyse mentionnée ci-dessus. Dans la pré-analyse de javascript, en plus de la pré-définition de la variable var, elle inclut également l'extraction de la définition de la fonction, donc la fonction. la fonction peut être définie n'importe où dans le script, appelée n'importe où. Sans se limiter à ce que c'était avant.

Mais la façon de définir les fonctions inclut une méthode appelée définition littérale, qui utilise la méthode var pour déclarer les fonctions. Voir ci-dessous

alert(typeof y3); //结果?
var y3 = function (){ console.log('1'); }

Rappelez-vous cette convention : l'appel doit apparaître après la déclaration. Pourquoi ? Si vous comprenez ce qui précède, la réponse ici est déjà claire. Le moteur javascript leur donnera une valeur initiale indéfinie lors de la pré-analyse de var. De cette façon, si nous l'appelons avant sa déclaration, le moteur javascript n'a pas encore obtenu sa vraie valeur, et signalera naturellement "xxx n'est pas une fonction". " Faux. Cela clarifie également pourquoi ce sont deux déclarations de fonction, mais l'une est liée à l'ordre de déclaration et d'appel, tandis que l'autre n'a pas de telles contraintes.

Conclusion

C'est une fonction, le résultat de l'exécution de js et de la modification dynamique, et suit toujours les règles de pré-analyse des variables (lors de l'alerte ci-dessus, elle n'a pas obtenu les informations de la fonction littérale).
Et si les deux étaient mélangés. Voir ci-dessous, il existe à la fois des variables et des fonctions pour y4.

alert(typeof y4); //结果?
function y4(){
  console.log('y4')
}
var y4;

Parce que la priorité de déclaration de la fonction dans la pré-analyse JavaScript est élevée, y4 est naturellement du type fonction, mais après que y4 se soit vu attribuer une valeur (le moteur js est en cours d'exécution en ce moment), son opération d'affectation à js sera Remplacer la déclaration de la fonction. Alors :

alert(typeof y5);
var y5 = 'angle';
function y5(){
  console.log('ghost');  
}
alert(y5);

Le premier résultat de l'alerte est la fonction car il se situe au sommet du processus d'exécution js. Lors de la deuxième alerte, sa valeur a été réécrite à 5 (ne vous laissez pas tromper par la position de définition de la fonction ci-dessous.)

En pensant séparément à l'analyse et à l'exécution de js, j'ai découvert que mes yeux se sont soudainement éclairés et que les réponses à de nombreuses questions ont naturellement émergé. Comme l'a dit l'auteur de cet article : « Une fois que vous avez compris l'environnement d'exécution, l'appel d'un objet, close Des concepts tels que les packages, la portée lexicale et les chaînes de portée peuvent facilement résoudre de nombreux phénomènes dans le langage JS "

En regardant maintenant, même dans cette langue où il y a beaucoup de choses incroyables, il y a de nombreuses raisons qui y remontent.

Comment faire un meilleur jugement des paramètres

Après avoir tant discuté ci-dessus, comment pouvons-nous le rapprocher du développement réel ? Étant donné que JavaScript a une lecture et une écriture inégales, comment pouvons-nous éviter de porter des jugements de paramètres sans signaler d'erreurs ?

ex :

if(cusVar){ //这里的判断，是不是存在隐含的问题呢。 }

如何严谨一些呢。

if(window['cusVar']) { //保证它不报错。
  //或者这样的判断也是可行的 window.cusVar | typeof cusVar !== 'undefined'
  //干活咯
}

最后补充又一个小quiz, (理解 预解析与执行的分离)

var y7 = 'test';
function fun1(){
  alert(y7);
  var y7 = 'sex';
}
fun1();

更多关于JavaScript相关内容感兴趣的读者可查看本站专题：《JavaScript切换特效与技巧总结》、《JavaScript查找算法技巧总结》、《JavaScript动画特效与技巧汇总》、《JavaScript错误与调试技巧总结》、《JavaScript数据结构与算法技巧总结》、《JavaScript遍历算法与技巧总结》及《JavaScript数学运算用法总结》

希望本文所述对大家JavaScript程序设计有所帮助。