Parlez de ma compréhension des prototypes JavaScript et des séries de fermeture (notes aléatoires 6)_compétences javascript

Lecture connexe : Parlez de ma compréhension du prototype JavaScript et de la série de fermetures (Shuishou Note 8)

Qu'est-ce qu'une fermeture

Qu'est-ce qu'une fermeture ? Closure est Closure, qui est une nouvelle fonctionnalité que les langages statiques n'ont pas. Mais la fermeture n'est pas quelque chose de trop compliqué à comprendre. En bref, la fermeture c'est :

• La fermeture est une collection de variables locales d'une fonction, mais ces variables locales continueront d'exister après le retour de la fonction.

• La fermeture signifie que la "pile" d'une fonction n'est pas libérée après le retour de la fonction. On peut aussi comprendre que ces piles de fonctions ne sont pas allouées sur la pile mais sur le tas

.

• Lors de la définition d'une autre fonction au sein d'une fonction, une fermeture sera générée

Qu'est-ce qu'un prototype ?

Un prototype est un objet à travers lequel d'autres objets peuvent implémenter l'héritage de propriétés.

Tout objet peut-il devenir un prototype ?

Oui

Quels objets ont des prototypes

Tous les objets ont un prototype par défaut, car le prototype lui-même est aussi un objet, donc chaque prototype lui-même a un prototype (à une exception près, le prototype d'objet par défaut est en haut de la chaîne des prototypes

).

Contexte d'exécution

Chaque fois que le contrôleur passe au code exécutable ECMAScript, il entre dans un contexte d'exécution.

Le contexte d'exécution (EC en abrégé) est un concept abstrait La norme ECMA-262 utilise ce concept pour le distinguer du concept de code exécutable.

La spécification standard ne définit pas avec précision le type et la structure d'EC du point de vue de la mise en œuvre technique ; cela devrait être un problème à prendre en compte lors de la mise en œuvre spécifique du moteur ECMAScript.

Les contextes d'exécution d'activités forment logiquement une pile. Le bas de la pile est toujours le contexte global et le haut de la pile est le contexte d'exécution actuel (actif). La pile est modifiée à mesure que différents types d'EC sont poussés ou sautés.

-------------------------------------------------------------- --- ------------------------------------

Situation 1 : Avant de prendre un morceau de code js et de l'exécuter phrase par phrase, le navigateur a déjà effectué un "travail préparatoire", qui inclut la déclaration de variables au lieu d'attribuer des valeurs. L'affectation de variable est effectuée lorsque l'instruction d'affectation est exécutée.

Cas 2 : Dans l'étape "préparation", ceci est attribué directement.

Copier le code Le code est le suivant :

console.log(this) //Fenêtre

Cas 3 : Fonction : expression de fonction et déclaration de fonction

 console.log(f1); //function f1() {}
function f1() {} //函数声明
console.log(f2); //undefined
var f2 = function() {}; //函数表达式 

Résumé de la « Préparation » :

•Variable, expression de fonction————Déclaration de variable, l'affectation par défaut n'est pas définie

•cette————affectation

•Déclaration de fonction————Affectation

Nous appelons la préparation de ces trois types de données « contexte d'exécution » ou « environnement de contexte d'exécution ».

-------------------------------------------------------------- --- ------------------------------------

Avant que JavaScript n'exécute un segment de code, il effectuera ces « travaux préparatoires » pour générer un contexte d'exécution. Ce « segment de code » est divisé en trois situations : code global, code de fonction et code d'évaluation.

 //全局代码段
<script type="text/javascript">
 //代码段...
</script>
//函数代码段
function fn(x) {
 console.log(x + 5);
}
var fn = new Function("x", "console.log(x + 5)");
//Eval代码段
eval('var x = 10');
(function foo() {
 eval('var y = 20');
})();
alert(x); //10
alert(y); //"y" is not defined
//因为eval涉及到安全问题(脚本注入),所以尽量不用。 

-------------------------------------------------------------- --- ------------------------------------

Dans la fonction, en plus de plusieurs situations de "préparation", il y aura aussi d'autres données

 function fn(x) {
 console.log(arguments); //[10]
 conosole.log(x); //10
}
fn(10); 

Le code ci-dessus montre que les variables d'arguments et les paramètres de fonction ont été attribués avant l'exécution des instructions dans le corps de la fonction.

Chaque fois que la fonction est appelée, un nouvel environnement d'exécution de contexte sera généré. Parce que différents appels peuvent produire différents paramètres.

La portée des variables libres à l'intérieur du corps de la fonction a été déterminée lorsque la fonction est définie (non appelée).

 var a = 10;
function fn() {
 console.log(a); //a是自由变量
}     //函数创建时，就确定了a要取值的作用域
function bar(f) {
 var a = 20;
 f(); //打印"10",而不是"20"
}
bar(fn); 

Résumé :

Le contenu des données contextuelles du code global est :

•Variables ordinaires (y compris les expressions de fonction), telles que : var a = 10 | ===> (l'affectation par défaut n'est pas définie)

•Déclaration de fonction, telle que function fn() {} ===>

•cette | ===>

Corps de fonction

•Paramètres | ===>

•arguments | ===> Affectation

•Portée des valeurs des variables libres | ====> Affectation

Définition populaire :

Avant d'exécuter le code, retirez au préalable toutes les variables qui seront utilisées. Certaines sont affectées directement, et certaines sont occupées par des variables indéfinies en premier.

Le contenu ci-dessus est la description complète du prototype JavaScript et de la compréhension de la série de fermeture (notes aléatoires 6) que l'éditeur a partagée avec vous.