如何取消设置 JavaScript 变量？

Question

我在 JavaScript 中有一个全局变量（实际上是一个 window 属性，但我认为这并不重要），它已经由以前的脚本填充，但我不希望稍后运行另一个脚本来查看它的价值或它甚至被定义。

我已经输入了some_var = undefined，它用于测试typeof some_var == "undefined"，但我真的认为这不是正确的方法。

你怎么看？

Answer 1

delete 运算符从对象中删除属性。它不能删除变量。所以问题的答案取决于全局变量或属性是如何定义的。

(1)如果用var创建，则不能删除。

例如：

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)如果创建时没有var，可以删除。

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

技术说明

1.使用var

在这种情况下，引用 g_a 是在 ECMAScript 规范所称的“VariableEnvironment”中创建的，它附加到当前范围 - 这可能是在使用 var 的情况下的函数执行上下文函数（尽管当您考虑let 时它可能会变得更复杂一些）或者在“全局”代码的情况下，VariableEnvironment 附加到全局对象（通常是window）。

VariableEnvironment 中的引用通常不可删除 - ECMAScript 10.5 中详述的过程详细解释了这一点，但只要说除非您的代码在 eval 上下文中执行（即大多数基于浏览器的开发控制台都使用），那么用var声明的变量不能被删除。

2.不使用var

当试图在不使用 var 关键字的情况下为名称分配值时，JavaScript 会尝试在 ECMAScript 规范所谓的“LexicalEnvironment”中定位命名引用，主要区别在于 LexicalEnvironment 是嵌套的——即 LexicalEnvironment 有一个父级（ECMAScript 规范称之为“外部环境引用”）并且当 JavaScript 无法在 LexicalEnvironment中定位引用时>，它在父 LexicalEnvironment 中查找（详见10.3.1 和10.2.2.1）。顶层 LexicalEnvironment 是“global environment”，它绑定到全局对象，因为它的引用是全局对象的属性。因此，如果您尝试访问未在当前作用域或任何外部作用域中使用 var 关键字声明的名称，JavaScript 最终将获取 window 对象的属性以用作该引用。正如我们之前所了解的，可以删除对象的属性。

注意事项

1. 重要的是要记住var 声明是“提升的”——即它们总是被认为发生在它们所在作用域的开头——尽管不是可以在@987654345 中完成的值初始化@ 声明 - 留在原处。所以在下面的代码中，a 是来自 VariableEnvironment 的引用，而不是 window 属性，它的值将是代码末尾的 10：

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

2. 以上讨论是在“严格模式”未启用的情况下进行的。使用“严格模式”时查找规则有点不同，在没有“严格模式”的情况下解析为窗口属性的词法引用将在“严格模式”下引发“未声明的变量”错误。我真的不明白这是在哪里指定的，但它是浏览器的行为方式。

Answer 2

scunliffe's answer 可以，但从技术上讲应该可以

delete window.some_var;

当目标不是对象属性时，

delete 应该是空操作。例如，

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

但由于全局变量实际上是窗口对象的成员，所以它可以工作。

当涉及原型链时，使用 delete 会变得更加复杂，因为它只会从目标对象中删除属性，而不是原型。例如，

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.

所以要小心。

注意：我的答案是somewhat inaccurate（见最后的“误解”）。该链接解释了所有血淋淋的细节，但总结是浏览器之间可能存在很大差异，具体取决于您要从中删除的对象。只要object !== window，delete object.someProp 通常应该是安全的。我仍然不会用它来删除用var 声明的变量，尽管你可以在适当的情况下。

Answer 3

如果您在没有var 的情况下隐式声明变量，则正确的方法是使用delete foo。

但是，在您删除它之后，如果您尝试在诸如添加之类的操作中使用它，则会抛出 ReferenceError，因为您无法将字符串添加到未声明、未定义的标识符中。示例：

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

在某些情况下，将它分配给 false、null 或 undefined 可能更安全，因此它被声明并且不会引发此类错误。

foo = false

请注意，在 ECMAScript 中，null、false、undefined、0、NaN 或 '' 都将计算为 false。只需确保在对布尔值进行类型检查时不要使用 !== 运算符，而是使用 != 并且您不希望进行身份检查（因此 null 将使用 == false 和 false == undefined）。

还要注意delete 不会“删除”引用，而只是直接在对象上的属性，例如：

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)

如果你用var声明了一个变量，你就不能删除它：

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

在犀牛中：

js> var x
js> delete x
false

你也不能删除一些预定义的属性，比如Math.PI：

js> delete Math.PI
false

delete 与任何语言都有一些奇怪的例外，如果你足够在意，你应该阅读：

• 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

Answer 4

详情请见noah's answer

//Option A.) set to null
some_var = null;

//Option B.) set to undefined
some_var = undefined;

//Option C.) remove/delete the variable reference
delete obj.some_var
//if your variable was defined as a global, you'll need to
//qualify the reference with 'window'
delete window.some_var;

参考资料：

• MDN delete API

• MDN SyntaxError when deleting an unqualified variable name in strict mode

Answer 5

TLDR：可以使用delete 删除简单定义的变量（没有var、let、const）。如果您使用var、let、const - 它们既不能用delete 也不能用Reflect.deleteProperty 删除。

铬 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"

Firefox Nightly 53.0a1 显示相同的行为。

Answer 6

ECMAScript 2015 提供 Reflect API。可以使用Reflect.deleteProperty() 删除对象属性：

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

要删除全局window 对象的属性：

Reflect.deleteProperty(window, 'some_var');

在某些情况下无法删除属性（当属性不可配置时），然后此函数返回false（以及delete operator）。在其他情况下，它返回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

deleteProperty 函数和delete 运算符在严格模式下运行时存在差异：

'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

Answer 7

⚠️ 接受的答案（和其他）已过时！

TL;DR

• delete不删除变量。
  （仅用于从对象中删除属性。）

• “取消设置”的正确方法是简单地将变量设置为null。 _(source)
  （这使 JavaScript 的自动进程能够删除 内存中的变量。）

示例：

x = null;

?

---

更多信息：

自 2012 年所有浏览器都实现（自动）mark-and-sweepgarbage-collection 以来，已弃用在变量上使用 delete 运算符。该过程通过自动确定对象/变量何时变为“unreachable”（确定代码是否仍需要它们）来工作。

在所有现代浏览器中使用 JavaScript：

• 垃圾收集是自动执行的。 我们无法强制或阻止。
• 对象在reachable 时保留在内存中。
• 被引用与可访问不同：一组相互关联的对象可能整体变得不可访问。 _(source)

delete 运算符仅用于从对象中删除属性； 它不会删除变量。

与普遍看法不同（可能是由于其他编程语言，如delete in C++），delete 运算符与直接释放内存无关。内存管理是通过中断引用间接完成的。 _(source)

当使用strict mode（'use strict';，而不是常规/"sloppy mode"）时，尝试删除变量将引发错误并且不允许。 JavaScript 中的普通变量无法使用 delete 运算符 _(source)（或任何其他方式，截至 2021 年）删除。

 

---

 

...唉，唯一的解决办法：

Freeing the contents of a variable

要释放变量的内容，您只需将其设置为null：

var x;

// ...

x = null;    // (x can now be garbage collected)

^(source)

---

延伸阅读：

• Memory Management（MDN 文档）
• Garbage Collection（厄勒布鲁大学）
• The Very Basics of Garbage Collection (javascript.info)
• Understanding JavaScript Memory Management using Garbage Collection
• Eradicating Memory Leaks In Javascript

Answer 8

与简单属性相比，变量具有 [[Configurable]] 属性，这意味着无法通过 delete 运算符删除变量。

但是，有一个执行上下文不受此规则影响。这是 eval 上下文：没有为变量设置 [[Configurable]] 属性。

Answer 9

注意delete 成功时返回true。

2021 年更新：在 Chrome 88 和 Firefox 84 上测试：

implicit_global = 1;
delete implicit_global; // true

window.explicit_global = 1;
delete explicit_global; // true

const _object = {property: 1};
delete _object.property; // true

function_set = function() {};
delete function_set; // true

function function_declaration() {};
delete function_declaration; // false

(function () {
    var _var = 1;
    console.log(delete _var); // false
    console.log(_var); // 1
})()

(function () {
    let _let = 1;
    console.log(delete _let); // false
    console.log(_let); // 1
})()

(function () {
    const _const = 1;
    console.log(delete _const); // false
    console.log(_const); // 1
})()

由于浏览器更新，此答案的先前编辑不再相关。

Answer 10

删除操作符从对象中删除一个属性。

delete object.property
delete object['property']

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

根据问题你需要以下之一

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

Answer 11

如果您在首次使用时声明了变量（使用var x;），则无法删除该变量。 但是，如果您的变量 x 首次出现在脚本中没有声明，那么您可以使用 delete 运算符 (delete x;) 并且您的变量将被删除，非常类似于删除数组的元素或删除对象的属性。

Answer 12

我有点困惑。如果您只想让变量值不传递给另一个脚本，则无需从范围中删除该变量。

只需使变量无效，然后显式检查它是否为 null。为什么要麻烦从范围中删除变量？这有什么作用而无效化不能？

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