Une brève analyse des compétences de déclaration_javascript des variables JavaScript

Peu importe où apparaît une instruction de déclaration de variable JavaScript, elle sera exécutée en premier avant tout autre code. La portée d'une variable déclarée à l'aide du mot-clé var est le contexte d'exécution actuel, qui peut être une fonction environnante, ou, lorsque la variable est déclarée en dehors du corps de la fonction, il s'agit d'une variable globale.

Les éléments définis en dehors du corps de la fonction sont des variables globales, et ceux définis à l'intérieur du corps de la fonction sont des variables locales. La définition ici fait référence à la déclaration via var.

JavaScript a le concept de globales implicites, ce qui signifie que toute variable que vous ne déclarez pas deviendra une propriété d'objet globale. Par exemple :

function test(){
myname = "huming";
alert(myname);
}
test();　　// "huming"
alert(myname);　　//"huming" 

Les deux résultats sont les mêmes, indiquant que myname est une variable globale.

Alors, y a-t-il une différence entre les variables globales implicites et les variables globales explicitement définies ? . La réponse est définitivement oui, regardez l'exemple ci-dessous :

// 定义三个全局变量
var global_test = ;
global_test = ; // 反面教材
(function () {
global_test = ; // 反面教材
}());
// 试图删除
delete global_test; // false
delete global_test; // true
delete global_test; // true
// 测试该删除
alert(typeof global_test); // "number"
alert(typeof global_test); // "undefined"
alert(typeof global_test); // "undefined" 

Comme le montre l'exemple ci-dessus : global_test1 défini par var en dehors de la fonction ne peut pas être supprimé, et global_test2 et global_test3 qui ne sont pas définis par var sont supprimés (qu'ils soient créés ou non dans le corps de la fonction).

En résumé, les variables globales déclarées via var en dehors de la fonction ne peuvent pas être supprimées, mais les variables globales implicites peuvent être supprimées.

Il convient de noter ici : JavaScript a un comportement appelé "hoisting" (suspension/analyse supérieure/pré-analyse).

Illustrons avec un exemple :

var myname = "huming"; //声明全局变量
function test() {
alert(myname);
var myname = "local_huming";
alert(myname);
}
test();

Pensez-vous que le contenu des deux alertes est cohérent ? ? Manifestement incohérent, il va sans dire cohérent. . La sortie réelle est : "undefined", "local_huming".

L'exemple ci-dessus est équivalent à

var myname = "huming"; //声明全局变量
function test() {
　　var myname;
　　alert(maname);<br>　　myname = "local_huming";
　　alert(myname); // "local"
}
test(); 

Le myname généré par la première alerte n'est pas la variable globale que vous pensez, mais une variable locale dans la même portée (un corps de fonction) avec elle. Même s’il n’a pas été déclaré, il est traité comme tel. C'est ce qu'on appelle le « levage ».

Cela devrait être clair. Lorsque vous utilisez une variable dans le corps d'une fonction et que vous la déclarez à nouveau ultérieurement, une erreur peut se produire.

Spécifications de rédaction :

function test() {
var a = ,
b = ,
c = a + b,
d = {},
e,
f;
// function body...
}

Les avantages sont :

1. Toutes les variables locales sont définies au début de la fonction pour une recherche facile

2. Empêchez les erreurs logiques lorsque des variables sont utilisées avant qu'elles ne soient définies.

En JavaScript, il existe quatre façons pour un nom de variable d'entrer dans la portée

Langage intégré, toutes les étendues ont des mots-clés this et arguments

Paramètres formels, les paramètres de fonction sont valables dans toute la portée

Déclaration de fonction

Déclaration des variables

Les quatre ordres répertoriés ci-dessus sont également l'ordre de priorité de haut en bas. Une fois qu'un nom de variable a été déclaré, il ne peut pas être écrasé par d'autres formulaires de déclaration de variable de priorité inférieure.