Comment désinstaller une variable JavaScript?

J'ai une variable globale en JavaScript (en fait une windowpropriété, mais je ne pense pas que ce soit important) qui était déjà remplie par un script précédent mais je ne veux pas qu'un autre script s'exécute plus tard pour voir sa valeur ou qu'il était même défini.

J'ai mis some_var = undefinedet cela fonctionne dans le but de tester, typeof some_var == "undefined"mais je ne pense vraiment pas que ce soit la bonne façon de procéder.

Qu'est-ce que tu penses?

L' deleteopérateur supprime une propriété d'un objet. Il ne peut pas supprimer une variable. La réponse à la question dépend donc de la façon dont la variable ou la propriété globale est définie.

(1) S'il est créé avec var, il ne peut pas être supprimé.

Par exemple:

var g_a = 1; //create with var, g_a is a variable 
delete g_a; //return false
console.log(g_a); //g_a is still 1

(2) S'il est créé sans var, il peut être supprimé.

g_b = 1; //create without var, g_b is a property 
delete g_b; //return true
console.log(g_b); //error, g_b is not defined

Explication technique

1. Utilisation var

Dans ce cas, la référence g_aest créée dans ce que la spécification ECMAScript appelle " VariableEnvironment " qui est attaché à la portée actuelle - cela peut être le contexte d'exécution d'une fonction dans le cas de l'utilisation à l' varintérieur d'une fonction (bien que cela puisse être un peu plus compliqué). quand on considère let) ou dans le cas du code "global", VariableEnvironment est attaché à l'objet global (souvent window).

Les références dans VariableEnvironment ne sont normalement pas supprimables - le processus détaillé dans ECMAScript 10.5 explique cela en détail, mais il suffit de dire qu'à moins que votre code ne soit exécuté dans un evalcontexte (que la plupart des consoles de développement basées sur un navigateur utilisent), les variables déclarées avec varne peuvent pas être supprimé.

2. Sans utiliser var

Lorsque vous essayez d'attribuer une valeur à un nom sans utiliser le varmot clé, Javascript essaie de localiser la référence nommée dans ce que la spécification ECMAScript appelle " LexicalEnvironment ", et la principale différence est que les LexicalEvironment sont imbriqués - c'est-à-dire qu'un LexicalEnvironment a un parent ( ce que la spécification ECMAScript appelle «référence d'environnement externe») et lorsque Javscript ne parvient pas à localiser la référence dans un environnement Lexical , il regarde dans l' environnement Lexical parent (comme détaillé en 10.3.1 et 10.2.2.1 ). Le plus haut niveau LexicalEnvironment est " l'environnement mondial", et qui est lié à l'objet global dans la mesure où ses références sont les propriétés de l'objet global. Donc, si vous essayez d'accéder à un nom qui n'a pas été déclaré à l'aide d'un varmot clé dans la portée actuelle ou dans une portée externe, Javascript finira par récupérer une propriété de l' windowobjet pour servir de référence. Comme nous l'avons vu précédemment, les propriétés des objets peuvent être supprimées.

Remarques

1. Il est important de se rappeler que les vardéclarations sont "hissées" - c'est-à-dire qu'elles sont toujours considérées comme étant survenues au début de la portée dans laquelle elles se trouvent - mais pas l'initialisation de la valeur qui peut être effectuée dans une varinstruction - qui reste là où elle est . Ainsi, dans le code suivant, aest une référence de VariableEnvironment et non la windowpropriété et sa valeur sera 10à la fin du code:

   function test() { a = 5; var a = 10; }

2. La discussion ci-dessus est lorsque le "mode strict" n'est pas activé. Les règles de recherche sont un peu différentes lors de l'utilisation du "mode strict" et les références lexicales qui auraient résolu les propriétés de la fenêtre sans "mode strict" déclencheront des erreurs "variable non déclarée" sous "mode strict". Je ne comprenais pas vraiment où cela est spécifié, mais son comportement des navigateurs.

La réponse de @ scunlife fonctionnera, mais techniquement, elle devrait être

delete window.some_var; 

delete est censé être un no-op lorsque la cible n'est pas une propriété d'objet. par exemple,

(function() {
   var foo = 123;
   delete foo; // wont do anything, foo is still 123
   var bar = { foo: 123 };
   delete bar.foo; // foo is gone
}());

Mais puisque les variables globales sont en fait membres de l'objet window, cela fonctionne.

Lorsque des chaînes de prototypes sont impliquées, l'utilisation de la suppression devient plus complexe car elle supprime uniquement la propriété de l'objet cible, et non du prototype. par exemple,

function Foo() {}
Foo.prototype = { bar: 123 };
var foo = new Foo();
// foo.bar is 123
foo.bar = 456;
// foo.bar is now 456
delete foo.bar;
// foo.bar is 123 again.

Donc sois prudent.

EDIT: Ma réponse est quelque peu inexacte (voir "Idées fausses" à la fin). Le lien explique tous les détails sanglants, mais le résumé est qu'il peut y avoir de grandes différences entre les navigateurs et selon l'objet que vous supprimez. delete object.somePropdevrait généralement être sûr aussi longtemps que object !== window. Je ne l'utiliserais toujours pas pour supprimer les variables déclarées avec varbien que vous puissiez dans les bonnes circonstances.

Si vous déclarez implicitement la variable sans var, la bonne façon serait d'utiliser delete foo.

Cependant, après l'avoir supprimé, si vous essayez de l'utiliser dans une opération telle que l'ajout, un ReferenceErrorsera levé car vous ne pouvez pas ajouter de chaîne à un identifiant non déclaré et non défini. Exemple:

x = 5;
delete x
alert('foo' + x )
// ReferenceError: x is not defined

Il peut être plus sûr dans certaines situations de l'affecter à false, null ou indéfini afin qu'il soit déclaré et ne génère pas ce type d'erreur.

foo = false

Notez que dans ECMAScript null, false, undefined, 0, NaNou ''serait tout à évaluer false. Assurez-vous simplement que vous n'utilisez pas l' !==opérateur mais à la place !=lors de la vérification de type pour les booléens et que vous ne voulez pas de vérification d'identité (comme le nullferait == falseet false == undefined).

Notez également que deletene "supprime" pas les références mais seulement les propriétés directement sur l'objet, par exemple:

bah = {}, foo = {}; bah.ref = foo;

delete bah.ref;
alert( [bah.ref, foo ] )
// ,[object Object] (it deleted the property but not the reference to the other object)

Si vous avez déclaré une variable avec varvous ne pouvez pas la supprimer:

(function() {
    var x = 5;
    alert(delete x)
    // false
})();

Dans Rhino:

js> var x
js> delete x
false

Vous ne pouvez pas non plus supprimer certaines propriétés prédéfinies comme Math.PI:

js> delete Math.PI
false

Il y a quelques exceptions étranges à deletecomme avec n'importe quelle langue, si vous vous souciez suffisamment, vous devriez lire:

• https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Operators/Special_Operators/delete_Operator
• http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-262.pdf

some_var = null;

//or remove it..
delete some_var;

TLDR: simples variables définies par (sans var, let, const) pourrait être supprimé avec delete. Si vous utilisez var, let, const- ils ne pouvaient pas être supprimés ni avec deleteni avec Reflect.deleteProperty.

Chrome 55:

simpleVar = "1";
"1"
delete simpleVar;
true
simpleVar;
VM439:1 Uncaught ReferenceError: simpleVar is not defined
    at <anonymous>:1:1
(anonymous) @ VM439:1
var varVar = "1";
undefined
delete varVar;
false
varVar;
"1"
let letVar = "1";
undefined
delete letVar;
true
letVar;
"1"
const constVar="1";
undefined
delete constVar;
true
constVar;
"1"
Reflect.deleteProperty (window, "constVar");
true
constVar;
"1"
Reflect.deleteProperty (window, "varVar");
false
varVar;
"1"
Reflect.deleteProperty (window, "letVar");
true
letVar;
"1"

FF Nightly 53.0a1 montre le même comportement.

ECMAScript 2015 propose l'API Reflect. Il est possible de supprimer la propriété d'objet avec Reflect.deleteProperty () :

Reflect.deleteProperty(myObject, 'myProp');
// it is equivalent to:
delete myObject.myProp;
delete myObject['myProp'];

Pour supprimer la propriété d'un windowobjet global :

Reflect.deleteProperty(window, 'some_var');

Dans certains cas, les propriétés ne peuvent pas être supprimées (lorsque la propriété n'est pas configurable), puis cette fonction revient false(ainsi que l' opérateur de suppression ). Dans les autres cas, retourne true:

Object.defineProperty(window, 'some_var', {
    configurable: false,
    writable: true,
    enumerable: true,
    value: 'some_val'
});

var frozen = Object.freeze({ myProperty: 'myValue' });
var regular = { myProperty: 'myValue' };
var blank = {};

console.log(Reflect.deleteProperty(window, 'some_var')); // false
console.log(window.some_var); // some_var

console.log(Reflect.deleteProperty(frozen, 'myProperty')); // false
console.log(frozen.myProperty); // myValue

console.log(Reflect.deleteProperty(regular, 'myProperty')); // true
console.log(regular.myProperty); // undefined

console.log(Reflect.deleteProperty(blank, 'notExistingProperty')); // true
console.log(blank.notExistingProperty); // undefined

Il y a une différence entre la deletePropertyfonction et l' deleteopérateur lorsqu'il est exécuté en mode strict:

'use strict'

var frozen = Object.freeze({ myProperty: 'myValue' });

Reflect.deleteProperty(frozen, 'myProperty'); // false
delete frozen.myProperty;
// TypeError: property "myProperty" is non-configurable and can't be deleted

Les variables, contrairement aux propriétés simples, ont l'attribut [[Configurable]] , ce qui signifie l'impossibilité de supprimer une variable via l' opérateur de suppression . Cependant, il existe un contexte d'exécution sur lequel cette règle n'affecte pas. C'est le contexte eval : l'attribut [[Configurable]] n'est pas défini pour les variables.

L'opérateur de suppression supprime une propriété d'un objet.

delete object.property
delete object['property']

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete

Selon la question, vous avez besoin de l'un des éléments suivants

delete some_var;
delete window.some_var;
delete window['some_var'];

En plus de ce que tout le monde avait écrit, notons également que les deleteretours booléens. Il peut vous dire si la suppression a réussi ou non.

Test sur Chrome, tout sauf letétait délassable. une fois deleteretourné, trueil les supprimait:

implicit_global = 1;
window.explicit_global = 1;
function_set = function() {};
function function_dec() { };
var declared_variable = 1;
let let_variable = 1;

delete delete implicit_global; // true, tested on Chrome 52
delete window.explicit_global; // true, tested on Chrome 52
delete function_set; // true, tested on Chrome 52
delete function_dec; // true, tested on Chrome 52
delete declared_variable; // true, tested on Chrome 52
delete let_variable; // false, tested on Chrome 78

Vous ne pouvez pas supprimer une variable si vous l'avez déclarée (avec var x;) au moment de la première utilisation. Cependant, si votre variable x est apparue pour la première fois dans le script sans déclaration, alors vous pouvez utiliser l'opérateur de suppression (delete x;) et votre variable sera supprimée, très similaire à la suppression d'un élément d'un tableau ou la suppression d'une propriété d'un objet .

Je suis un peu confus. Si tout ce que vous voulez, c'est qu'une valeur de variable ne passe pas à un autre script, il n'est pas nécessaire de supprimer la variable de la portée. Annulez simplement la variable puis vérifiez explicitement si elle est ou non nulle. Pourquoi se donner la peine de supprimer la variable de la portée? À quoi sert ce serveur qui annulant ne peut pas?

foo = null;
if(foo === null) or if(foo !== null)