Jak rozbroić zmienną JavaScript?

Mam zmienną globalną w JavaScript (właściwie windowwłaściwość, ale nie sądzę, żeby to miało znaczenie), która została już zapełniona przez poprzedni skrypt, ale nie chcę innego skryptu, który uruchomi się później, aby zobaczyć jego wartość lub że był nawet zdefiniowane.

Włożyłem some_var = undefinedi działa w celu testowania, typeof some_var == "undefined"ale naprawdę nie sądzę, że jest to właściwy sposób, aby to zrobić.

Co myślisz?

deleteOperator usuwa własności z obiektu. Nie można usunąć zmiennej. Odpowiedź na pytanie zależy więc od sposobu zdefiniowania zmiennej globalnej lub właściwości.

(1) Jeśli jest utworzony var, nie można go usunąć.

Na przykład:

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) Jeśli zostanie utworzony bez var, można go usunąć.

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

Wyjaśnienie techniczne

1. Korzystanie var

W tym przypadku odwołanie g_ajest tworzone w tym, co specyfikacja ECMAScript nazywa „ VariableEnvironment ”, które jest dołączone do bieżącego zakresu - może to być kontekst wykonania funkcji w przypadku użycia varwewnątrz funkcji (choć może być nieco bardziej skomplikowany jeśli weźmiesz pod uwagę let) lub w przypadku kodu „globalnego” środowisko zmienne jest dołączane do obiektu globalnego (często window).

Odwołania w środowisku VariableEnvironment zwykle nie są usuwalne - proces szczegółowo opisany w ECMAScript 10.5 wyjaśnia to szczegółowo, ale wystarczy powiedzieć, że jeśli twój kod nie jest wykonywany w evalkontekście (z którego korzysta większość konsol programistycznych opartych na przeglądarce), to zmienne zadeklarowane za varpomocą nie mogą zostać usunięte.

2. Bez użycia var

Gdy próbuje przypisać wartość do nazwy bez użycia varsłowa kluczowego, JavaScript próbuje zlokalizować nazwie odniesienie w nazywa ECMAScript Spec „ LexicalEnvironment ”, a główną różnicą jest to, że LexicalEvironment s są zagnieżdżone - czyli LexicalEnvironment ma rodzica ( co specyfikacja ECMAScript nazywa „referencją środowiska zewnętrznego”), a gdy Javscript nie może zlokalizować referencji w środowisku LexicalEenvironment , sprawdza je w macierzystym środowisku LexicalEnvironment (jak szczegółowo opisano w 10.3.1 i 10.2.2.1 ). LexicalEnvironment najwyższego poziomu to „ środowisko globalne”, a to jest powiązane z obiektem globalnym, ponieważ jego odwołania są właściwościami obiektu globalnego. Jeśli więc spróbujesz uzyskać dostęp do nazwy, która nie została zadeklarowana przy użyciu varsłowa kluczowego w bieżącym zakresie lub jakimkolwiek zasięgu zewnętrznym, JavaScript ostatecznie pobierze właściwość z windowobiektu, aby służyć jako tego odniesienia. jak dowiedzieliśmy się wcześniej, na właściwości obiektów mogą zostać usunięte.

Notatki

1. Ważne jest, aby pamiętać, że vardeklaracje są „podnoszone” - tzn. Zawsze uważa się, że miały miejsce na początku zakresu, w którym się znajdują - choć nie inicjalizacja wartości, którą można wykonać w varinstrukcji - pozostawia się tam, gdzie jest . Zatem w poniższym kodzie aznajduje się odwołanie z VariableEnvironment, a nie windowwłaściwość, a jego wartość będzie 10na końcu kodu:

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

2. Powyższa dyskusja dotyczy sytuacji, gdy „tryb ścisły” nie jest włączony. Reguły wyszukiwania są nieco inne, gdy używa się „trybu ścisłego”, a odniesienia leksykalne, które zostałyby rozstrzygnięte we właściwościach okna bez „trybu ścisłego”, spowodują błędy „niezadeklarowanej zmiennej” w „trybie ścisłym”. Naprawdę nie rozumiałem, gdzie to jest określone, ale jak działają przeglądarki.

Odpowiedź @ scunlife zadziała, ale technicznie powinna być

delete window.some_var; 

delete ma być opcją, gdy cel nie jest właściwością obiektu. na przykład,

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

Ale ponieważ zmienne globalne są faktycznie elementami obiektu okna, działa.

Gdy zaangażowane są łańcuchy prototypów, użycie delete staje się bardziej złożone, ponieważ usuwa tylko właściwość z obiektu docelowego, a nie prototypu. na przykład,

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.

Więc uważaj.

EDYCJA: Moja odpowiedź jest nieco niedokładna (patrz „Błędne przekonania” na końcu). Link wyjaśnia wszystkie krwawe szczegóły, ale podsumowanie jest takie, że mogą istnieć duże różnice między przeglądarkami i w zależności od obiektu, z którego usuwasz. delete object.someProppowinny być ogólnie bezpieczne, o ile object !== window. Nadal nie używałbym tego do usuwania zadeklarowanych zmiennych, varchociaż można to zrobić w odpowiednich okolicznościach.

Jeśli domyślnie deklarujesz zmienną bez var, właściwym sposobem byłoby użycie delete foo.

Jednak po jego usunięciu próba użycia tego w operacji, takiej jak dodawanie, ReferenceErrorspowoduje wyrzucenie, ponieważ nie można dodać ciągu do niezadeklarowanego, niezdefiniowanego identyfikatora. Przykład:

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

W niektórych sytuacjach bezpieczniejsze może być przypisanie go do wartości false, null lub undefined, aby został zadeklarowany i nie generował tego typu błędu.

foo = false

Należy zauważyć, że w ECMAScript null, false, undefined, 0, NaN, lub ''by wszystko aby ocenić false. Po prostu upewnij się, że nie używasz !==operatora, ale zamiast tego !=podczas sprawdzania typu dla booleanów i nie chcesz sprawdzania tożsamości (tak nullby == falsei false == undefined).

Należy również pamiętać, że deletenie „usuwa” odniesień, a jedynie właściwości bezpośrednio na obiekcie, np .:

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)

Jeśli zadeklarowałeś zmienną var, nie możesz jej usunąć:

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

W nosorożcu:

js> var x
js> delete x
false

Nie można również usunąć niektórych predefiniowanych właściwości, takich jak Math.PI:

js> delete Math.PI
false

Istnieją pewne dziwne wyjątki, deletejak w każdym języku, jeśli dbasz wystarczająco, powinieneś przeczytać:

• 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: proste zdefiniowane zmienne (bez var,let , const) może być usunięty z delete. Jeśli używasz var, let, const- nie mogli być usunięte ani z deleteani 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 pokazuje to samo zachowanie.

ECMAScript 2015 oferuje API Reflect. Możliwe jest usunięcie właściwości obiektu za pomocą Reflect.deleteProperty () :

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

Aby usunąć właściwość windowobiektu globalnego :

Reflect.deleteProperty(window, 'some_var');

W niektórych przypadkach właściwości nie można usunąć (gdy właściwości nie można skonfigurować), a następnie funkcja ta zwraca false(podobnie jak operator usuwania ). W innych przypadkach zwraca 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

W trybie ścisłym istnieje różnica między deletePropertyfunkcją a deleteoperatorem:

'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

Zmienne, w przeciwieństwie do prostych właściwości, mają atrybut [[Konfigurowalny]] , co oznacza niemożność usunięcia zmiennej za pomocą operatora delete . Istnieje jednak jeden kontekst wykonania, na który ta reguła nie ma wpływu. Jest to kontekst ewaluacyjny : dla zmiennych nie ustawiono atrybutu [[Konfigurowalny]].

Operator usuwania usuwa właściwość z obiektu.

delete object.property
delete object['property']

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

Zgodnie z pytaniem potrzebujesz jednego z poniższych

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

Oprócz tego, co wszyscy napisali, zauważ również, że deletezwraca wartość logiczną. Może ci powiedzieć, czy usunięcie się powiodło, czy nie.

Testując na Chrome, wszystko oprócz można letbyło usunąć. po deletezwróceniu truefaktycznie je usunął:

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

Nie możesz usunąć zmiennej, jeśli zadeklarowałeś ją (przy pomocy var x;) podczas pierwszego użycia. Jeśli jednak twoja zmienna x pojawiła się po raz pierwszy w skrypcie bez deklaracji, możesz użyć operatora delete (delete x;), a twoja zmienna zostanie usunięta, bardzo podobnie do usuwania elementu tablicy lub usuwania właściwości obiektu .

Jestem trochę zmieszany. Jeśli wszystko, czego potrzebujesz, to aby zmienne nie były przekazywane do innego skryptu, nie ma potrzeby usuwania zmiennej z zakresu. Po prostu zeruj zmienną, a następnie jawnie sprawdź, czy jest ona zerowa. Po co męczyć się z usuwaniem zmiennej z zakresu? W jakim celu nie może tego serwera anulować?

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