Jak wyłączyć zmienną JavaScript?

@scunlife ' s answer will work, but formalnie it should be

delete window.some_var; 

Delete ma być no-op, gdy obiekt docelowy nie jest właściwością obiektu. np.,

(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ą rzeczywiście członkami obiektu window, to działa.

Gdy używane 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. np.,

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.

EDIT: moja odpowiedź brzmi nieco niedokładne (patrz "nieporozumienia" na końcu). Link wyjaśnia wszystkie krwawe szczegóły, ale podsumowanie jest takie, że mogą występować duże różnice między przeglądarkami i w zależności od obiektu, z którego usuwasz. delete object.someProp powinny być ogólnie bezpieczne tak długo, jak object !== window. Nadal nie używałbym go do usuwania zmiennych zadeklarowanych przez var, chociaż 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 usunięciu go, jeśli spróbujesz użyć go w operacji takiej jak dodanie, ReferenceError zostanie wyrzucony, ponieważ nie możesz dodać ciągu znaków do niezgłoszonego, 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 false, null lub undefined, aby został zadeklarowany i nie wyrzuci tego typu błędu.

foo = false

Zauważ, że w ECMAScript null, false, undefined, 0, NaN, lub '' wszystkie ocenią na false. Po prostu upewnij się, że nie używasz operatora !==, ale zamiast tego != podczas sprawdzania typu dla wartości logicznych i nie chcesz sprawdzania tożsamości (więc null będzie == false i false == undefined).

Zauważ również, że delete nie "usuwa" referencji, 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ą za pomocą var nie możesz jej usunąć:

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

W Rhino:

js> var x
js> delete x
false

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

js> delete Math.PI
false

Istnieją pewne dziwne wyjątki od delete jak w każdym języku, jeśli zależy ci na tyle 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żna usunąć za pomocą delete. W przypadku stosowania var, let, const - nie można ich usunąć ani za pomocą delete, ani za pomocą 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ść obiektu global window:

Reflect.deleteProperty(window, 'some_var');

W niektórych przypadkach właściwości nie można usunąć (gdy właściwość nie jest konfigurowalna) i wtedy ta funkcja zwraca false (jak również operator delete ). 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

Istnieje różnica między funkcją deleteProperty a operatorem delete podczas uruchamiania w tryb ścisły:

'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

Operator delete 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 następujących pytań

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

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

UPDATE:

Testując najnowszą Chrome, wszystko można było usunąć. delete funkcja zwróciła true dla wszystkich następujących metod i faktycznie je usunęła:

implicit_global = 1;
window.explicit_global = 1;
function_set = function() {};
function function_dec() { };
var declared_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

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 zasada ta nie ma wpływu. Jest to kontekst eval : tam [[konfigurowalny]] atrybut nie jest ustawiony dla zmiennych.

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