Analyse approfondie de la préparation et des effets secondaires dans JavaScriptvar

Effets secondaires de var

Il existe une petite différence entre les variables globales implicites et les variables globales explicitement définies, qui est la possibilité de laisser les variables indéfinies via l'opérateur de suppression.

Les variables globales créées via var (créées dans tout programme autre que les fonctions) ne peuvent pas être supprimées.

Les variables globales implicites créées sans var (qu'elles soient créées ou non dans une fonction) peuvent être supprimées.

Cela montre que, techniquement, les variables globales implicites ne sont pas vraiment des variables globales, mais ce sont des propriétés de l'objet global. Les propriétés peuvent être supprimées via l'opérateur delete, mais pas les variables :

// 定义三个全局变量
var global_var = 1;
global_novar = 2; 		// 反面教材
(function () {
   global_fromfunc = 3; // 反面教材
}());

// 试图删除
delete global_var; 		// false
delete global_novar; 	// true
delete global_fromfunc; // true

// 测试该删除
typeof global_var; 		// "number"
typeof global_novar; 	// "undefined"
typeof global_fromfunc; // "undefined"

En mode strict ES5, les variables non déclarées (telles que les deux opposés dans l'extrait de code précédent du manuel) généreront une erreur quand on travaille.

Formulaire var unique

L'utilisation d'une seule instruction var en haut d'une fonction est un formulaire plus utile. L'avantage est :

fournit un emplacement unique pour. go Trouver toutes les variables locales nécessaires à la fonction

Empêche les erreurs logiques lorsque les variables sont utilisées avant qu'elles ne soient définies

Vous aide à vous souvenir des variables globales déclarées, donc il y a moins de variables globales //zxx:ici Je suis moi-même un peu confus...

Moins de code (type, valeur et complétion d'une seule ligne)

Le formulaire var unique ressemble à ceci :

function func() {
   var a = 1,
       b = 2,
       sum = a + b,
       myobject = {},
       i,
       j;
   // function body...
}

Vous pouvez déclarer plusieurs variables en utilisant une seule instruction var, séparées par des virgules. C'est une bonne idée d'initialiser les variables et les valeurs en même temps comme ceci. Cela évite les erreurs logiques (la valeur initiale de toutes les variables non initialisées mais déclarées n'est pas définie) et augmente la lisibilité du code. Après avoir vu le code, vous pouvez connaître l'objectif général de ces variables en fonction des valeurs initialisées, par exemple si elles doivent être utilisées comme objets ou comme entiers.

Vous pouvez également effectuer un travail réel lors de la déclaration, comme sum = a + b dans le code précédent. Un autre exemple est que lorsque vous utilisez des références DOM (Document Object Model), vous pouvez utiliser une seule variable pour spécifier. Le DOM fait référence ensemble en tant que variables locales, comme indiqué dans le code suivant :

function updateElement() {
   var el = document.getElementById("result"),
       style = el.style;
   // 使用el和style干点其他什么事...
}

préparation des variables vars

En JavaScript, vous pouvez déclarer plusieurs instructions var n'importe où dans une fonction et ils agiront comme s'ils étaient déclarés en haut de la fonction, un comportement appelé levage. Des erreurs logiques peuvent survenir lorsque vous utilisez une variable, puis que vous la redéclarez ultérieurement dans une fonction. Pour JavaScript, tant que votre variable est dans la même portée (même fonction), elle est considérée comme déclarée, même lorsqu'elle est utilisée avant la déclaration var. Regardez l'exemple suivant :

// 反例
myname = "global"; // 全局变量
function func() {
    alert(myname); // "undefined"
    var myname = "local";
    alert(myname); // "local"
}
func();

Dans cet exemple, vous pouvez penser que la première alerte apparaît "globale" et la deuxième alerte apparaît "loacl". Cette attente est compréhensible, car au moment de la première alerte, monnom n'était pas déclaré. À ce moment-là, la fonction doit naturellement regarder la variable globale monnom, mais ce n'est pas réellement ainsi qu'elle fonctionne. La première alerte apparaîtra "indéfinie" car monnom est traité comme une variable locale de la fonction (même s'il est déclaré plus tard) et toutes les déclarations de variables sont suspendues en haut de la fonction. Par conséquent, pour éviter cette confusion, il est préférable de déclarer à l’avance toutes les variables que vous souhaitez utiliser.

L'extrait de code ci-dessus pourrait se comporter comme ceci :

myname = "global"; // global variable
function func() {
   var myname; // 等同于 -> var myname = undefined;
   alert(myname); // "undefined"
   myname = "local";
   alert(myname); // "local"}
func();

Par souci d'exhaustivité, mentionnons quelque chose d'un peu plus compliqué au niveau de l'exécution. Le traitement du code est divisé en deux étapes. La première étape est la création de variables, de fonctions et de paramètres au format normal. La deuxième phase est l'exécution du code, où les expressions de fonction et les identifiants non qualifiés (pour les variables déclarées) sont créés. Cependant, pour des raisons pratiques, nous adopterons la notion de « levage », qui n'est pas définie dans le standard ECMAScript et est généralement utilisée pour décrire un comportement.

Accès à l'objet global

Dans le navigateur, l'objet global est accessible n'importe où dans le code via l'attribut window (sauf si vous faites quelque chose de scandaleux, comme déclarer une variable locale fenêtre nommée). Mais dans d'autres contextes, cette propriété de commodité pourrait être appelée autrement (ou même ne pas être disponible dans le programme). Si vous devez accéder à l'objet global sans identifiant de fenêtre codé en dur, vous pouvez effectuer les opérations suivantes à n'importe quel niveau de portée de la fonction :

var global = (function () {
   return this;
}());

Cette méthode peut être utilisée à n'importe quel niveau. time Obtenez l'objet global, car il est appelé comme fonction dans la fonction (non construit via new), cela pointe toujours vers l'objet global. En fait, ce bug ne s'applique pas au mode strict d'ECMAScript 5, vous devez donc prendre une forme différente en mode strict. Par exemple, si vous développez une bibliothèque JavaScript, vous pouvez envelopper votre code dans une fonction immédiate, puis transmettre une référence à celle-ci depuis la portée globale comme argument à votre fonction immédiate.

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!