Wie deaktiviere ich eine JavaScript-Variable?

Ich habe eine globale Variable in JavaScript (eigentlich eine windowEigenschaft, aber ich denke nicht, dass es wichtig ist), die bereits von einem vorherigen Skript gefüllt wurde, aber ich möchte nicht, dass ein anderes Skript, das später ausgeführt wird, seinen Wert sieht oder dass es gerade ist definiert.

Ich habe es gesetzt some_var = undefinedund es funktioniert zum Zweck des Testens, typeof some_var == "undefined"aber ich denke wirklich nicht, dass es der richtige Weg ist, dies zu tun.

Was denken Sie?

Der deleteOperator entfernt eine Eigenschaft aus einem Objekt. Eine Variable kann nicht entfernt werden. Die Antwort auf die Frage hängt also davon ab, wie die globale Variable oder Eigenschaft definiert ist.

(1) Wenn es mit erstellt wurde var, kann es nicht gelöscht werden.

Zum Beispiel:

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) Wenn es ohne erstellt wird var, kann es gelöscht werden.

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

Technische Erklärung

1. Verwenden von var

In diesem Fall wird die Referenz g_ain der ECMAScript-Spezifikation " VariableEnvironment " erstellt, die an den aktuellen Bereich angehängt ist. Dies kann der Kontext für die varFunktionsausführung sein, wenn eine Funktion verwendet wird (obwohl dies etwas komplizierter werden kann) Wenn Sie dies berücksichtigen let) oder im Fall von "globalem" Code wird die VariableEnvironment (häufig window) an das globale Objekt angehängt .

Verweise in der Variablenumgebung sind normalerweise nicht löschbar - der in ECMAScript 10.5 beschriebene Prozess erklärt dies ausführlich, reicht jedoch aus, um zu sagen, dass evalVariablen, mit denen die meisten browserbasierten Entwicklungskonsolen deklariert varsind, nicht ausgeführt werden können, sofern Ihr Code nicht in einem Kontext ausgeführt wird (den die meisten browserbasierten Entwicklungskonsolen verwenden) gelöscht werden.

2. Ohne zu verwenden var

Beim Versuch, einem Namen einen Wert zuzuweisen, ohne das varSchlüsselwort zu verwenden, versucht Javascript, die benannte Referenz in der ECMAScript-Spezifikation " LexicalEnvironment " zu finden. Der Hauptunterschied besteht darin, dass LexicalEvironments verschachtelt sind - das heißt, LexicalEnvironment hat ein übergeordnetes Element ( Was die ECMAScript-Spezifikation als "Referenz für die äußere Umgebung" bezeichnet) und wenn Javscript die Referenz in einer LexicalEenvironment nicht findet , wird sie in der übergeordneten LexicalEnvironment angezeigt (wie in 10.3.1 und 10.2.2.1 beschrieben ). Die LexicalEnvironment der obersten Ebene ist die " globale Umgebung"", und das ist an das globale Objekt gebunden, da seine Referenzen die Eigenschaften des globalen Objekts sind. Wenn Sie also versuchen, auf einen Namen zuzugreifen, der nicht mit einem varSchlüsselwort im aktuellen Bereich oder einem äußeren Bereich deklariert wurde, ruft Javascript schließlich eine Eigenschaft ab des windowObjekts als dieser Referenz zu dienen. wie wir bereits gelernt haben, Eigenschaften auf Objekte gelöscht werden können.

Anmerkungen

1. Es ist wichtig, sich daran zu erinnern, dass varDeklarationen "gehisst" werden - dh sie werden immer als am Anfang des Bereichs betrachtet betrachtet, in dem sie sich befinden - obwohl nicht die Wertinitialisierung, die in einer varAnweisung durchgeführt werden kann -, die dort belassen wird, wo sie ist . Im folgenden Code abefindet sich also eine Referenz aus der Variablenumgebung und nicht die windowEigenschaft, und ihr Wert befindet sich 10am Ende des Codes:

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

2. Die obige Diskussion ist, wenn "strikter Modus" nicht aktiviert ist. Suchregeln sind etwas anders, wenn der "strenge Modus" verwendet wird, und lexikalische Verweise, die ohne "strengen Modus" in Fenstereigenschaften aufgelöst worden wären, führen im "strengen Modus" zu Fehlern bei "nicht deklarierten Variablen". Ich habe nicht wirklich verstanden, wo dies angegeben ist, aber wie sich Browser verhalten.

Die Antwort von @ scunlife wird funktionieren, aber technisch sollte es sein

delete window.some_var; 

Löschen soll ein No-Op sein, wenn das Ziel keine Objekteigenschaft ist. z.B,

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

Da globale Variablen jedoch tatsächlich Mitglieder des Fensterobjekts sind, funktioniert dies.

Wenn Prototypketten beteiligt sind, wird die Verwendung von delete komplexer, da nur die Eigenschaft aus dem Zielobjekt und nicht aus dem Prototyp entfernt wird. z.B,

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.

Also sei vorsichtig.

EDIT: Meine Antwort ist etwas ungenau (siehe "Missverständnisse" am Ende). Der Link erklärt alle wichtigen Details, aber die Zusammenfassung ist, dass es große Unterschiede zwischen Browsern geben kann und abhängig von dem Objekt, aus dem Sie löschen. delete object.somePropsollte im Allgemeinen sicher sein, solange object !== window. Ich würde es immer noch nicht verwenden, um Variablen zu löschen, mit vardenen deklariert wurde, obwohl Sie dies unter den richtigen Umständen können.

Wenn Sie die Variable implizit ohne deklarieren var, ist der richtige Weg, sie zu verwenden delete foo.

Wenn Sie jedoch versuchen, dies in einem Vorgang wie dem Hinzufügen von a zu verwenden, ReferenceErrorwird nach dem Löschen a ausgelöst, da Sie einem nicht deklarierten, nicht definierten Bezeichner keine Zeichenfolge hinzufügen können. Beispiel:

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

In einigen Situationen kann es sicherer sein, es false, null oder undefined zuzuweisen, damit es deklariert wird und diese Art von Fehler nicht auslöst.

foo = false

Beachten Sie, dass in ECMAScript null, false, undefined, 0, NaN, oder ''würde alles bewerten zu false. Stellen Sie nur sicher, dass Sie nicht den !==Operator verwenden, sondern stattdessen !=bei der Typprüfung auf Boolesche Werte und Sie möchten keine Identitätsprüfung (so nullwürde == falseund false == undefined).

Beachten Sie auch, dass deletekeine Referenzen "gelöscht" werden, sondern nur Eigenschaften direkt auf dem Objekt, z.

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)

Wenn Sie eine Variable mit deklariert haben, varkönnen Sie sie nicht löschen:

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

In Rhino:

js> var x
js> delete x
false

Sie können auch einige vordefinierte Eigenschaften wie Math.PI:

js> delete Math.PI
false

Es gibt einige merkwürdige Ausnahmen deletewie bei jeder Sprache. Wenn Sie sich genug darum kümmern, sollten Sie lesen:

• 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: einfach definierte Variablen (ohne var, let, const) konnte mit gelöscht werden delete. Wenn Sie ,, verwenden var, letkonnten constsie weder mit deletenoch mit gelöscht werden 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 zeigt das gleiche Verhalten.

ECMAScript 2015 bietet Reflect API. Es ist möglich, Objekteigenschaften mit Reflect.deleteProperty () zu löschen :

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

So löschen Sie die Eigenschaft eines globalen windowObjekts:

Reflect.deleteProperty(window, 'some_var');

In einigen Fällen können Eigenschaften nicht gelöscht werden (wenn die Eigenschaft nicht konfigurierbar ist), und dann kehrt diese Funktion zurück false(sowie der Löschoperator ). In anderen Fällen Rückgabe 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

Im strengen Modus gibt es einen Unterschied zwischen deletePropertyFunktion und deleteBediener:

'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

Variablen haben im Gegensatz zu einfachen Eigenschaften das Attribut [[Konfigurierbar]] , was bedeutet, dass es unmöglich ist, eine Variable über den Löschoperator zu entfernen . Es gibt jedoch einen Ausführungskontext, auf den sich diese Regel nicht auswirkt. Dies ist der Bewertungskontext : Das Attribut [[Konfigurierbar]] ist für Variablen nicht festgelegt.

Der Löschoperator entfernt eine Eigenschaft aus einem Objekt.

delete object.property
delete object['property']

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

Entsprechend der Frage benötigen Sie eine der folgenden Möglichkeiten

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

Beachten Sie zusätzlich zu dem, was alle geschrieben haben, auch, dass deleteBoolesche Werte zurückgegeben werden. Es kann Ihnen sagen, ob der Löschvorgang erfolgreich war oder nicht.

Beim Testen auf Chrome war alles außer letlöschbar. bei der deleteRückgabe wurden truesie tatsächlich entfernt:

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

Sie können eine Variable nicht löschen, wenn Sie sie zum Zeitpunkt der ersten Verwendung (mit var x;) deklariert haben. Wenn Ihre Variable x jedoch zum ersten Mal ohne Deklaration im Skript angezeigt wurde, können Sie den Löschoperator (delete x;) verwenden. Ihre Variable wird gelöscht, ähnlich wie beim Löschen eines Elements eines Arrays oder beim Löschen einer Eigenschaft eines Objekts .

Ich bin etwas verwirrt. Wenn Sie lediglich möchten, dass ein Variablenwert nicht an ein anderes Skript übergeben wird, müssen Sie die Variable nicht aus dem Bereich löschen. Machen Sie die Variable einfach ungültig und prüfen Sie dann explizit, ob sie null ist oder nicht. Warum sollten Sie sich die Mühe machen, die Variable aus dem Gültigkeitsbereich zu löschen? Welchen Zweck hat dieser Server, den das Aufheben nicht kann?

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