JavaScript montre la différence entre les variables globales et les variables globales implicites

Cet article présente principalement la différence entre les variables globales d'affichage javascript et les variables globales implicites. Les amis dans le besoin peuvent s'y référer

En JavaScript, il existe deux façons de déclarer des variables globales

• Utilisez var pour afficher les variables globales déclarées

• Variables globales implicites déclarées sans var

La différence entre les deux Cela dépend s'il peut être supprimé via l'opérateur de suppression

Premier coup d'oeil à un morceau de code

var a = 'a'; // 显式声明的全局变量
b = 'b'; // 隐式声明的全局变量
 
console.log(a); // a
console.log(b); // b
console.log(window.a); // a
console.log(window.b); // b

En js, les variables globales sont en fait attribut global object (window ), afin que les variables globales déclarées des deux manières puissent être obtenues via window

Essayez d'utiliser delete pour supprimer

// 显式声明的全局变量不能被删除
delete a; // 返回 false 
 
// 隐式声明的全局变量可以被删除
delete b; // 返回 true 
 
// 删除情况
console.log(typeof a); // string
console.log(typeof b); // undefined

L'opérateur delete peut supprimer les attributs d'un objet, mais si l'attribut est un attribut non configurable, false sera renvoyé lors de la suppression (une exception sera levée en mode strict)

Cela signifie que les variables déclarées à l'aide de var ne sont pas configurables. Utilisez getOwnPropertyDescriptor pour obtenir l'objet décrivant les caractéristiques de la propriété afin de vérifier cela

Object.getOwnPropertyDescriptor(window, a); // {value: "a", writable: true, enumerable: true, configurable: false}
Object.getOwnPropertyDescriptor(window, b); // {value: "b", writable: true, enumerable: true, configurable: true}

Les deux La différence fondamentale. est que les variables explicitement déclarées ne sont pas configurables et ne peuvent pas être supprimées via l'opérateur delete

Il est à noter qu'une fois que la valeur configurable est fausse, l'objet décrivant les caractéristiques de l'attribut ne peut pas être modifié, donc le descripteur d'attribut ne peut pas être modifié. Cela permet de supprimer les variables globales explicitement déclarées par delete, mais permet à l'inverse de ne pas supprimer les variables globales implicitement déclarées par delete

b = 'b';
var descriptor = Object.getOwnPropertyDescriptor(window, b);
descriptor.configurable = false;
Object.defineProperty(window, b, descriptor);
delete b; // 返回 false

suite aux suppléments. d'autres internautes

Variables globales et variables globales implicites en JavaScript

Il existe quelques petites différences entre les variables globales implicites et les variables globales explicitement définies, qui consistent à utiliser l'opérateur de suppression pour rendre les variables indisponibles . Capacités définies.

1. Les variables globales créées via var (créées dans tout programme autre que les fonctions) ne peuvent pas être supprimées.
2. 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 attributs peuvent être supprimés via l'opérateur delete, mais les variables ne peuvent pas :

// 定义三个全局变量
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"

Dans le navigateur, l'objet global peut être utilisé dans le code via la fenêtre attribut Accès depuis n'importe quel endroit (sauf si vous faites quelque chose de scandaleux, comme déclarer une variable locale nommée window). 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 dans la portée de la fonction à n'importe quel niveau :

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

Ceci La méthode peut obtenir l'objet global à tout moment, car elle est appelée en tant que fonction dans la fonction (non construite via new), et 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 lui transmettre une référence depuis la portée globale en tant que paramètre de votre fonction immédiate.

Ce qui précède est la différence entre les variables globales d'affichage javascript et les variables globales implicites. La différence fondamentale entre les deux est que les variables explicitement déclarées ne sont pas configurables et ne peuvent pas être supprimées via l'opérateur de suppression

Plus javascript display Pour les articles connexes sur la différence entre les variables globales et les variables globales implicites, veuillez faire attention au site Web PHP chinois !