Как сбросить переменную JavaScript?

У меня есть глобальная переменная в JavaScript (на самом деле это windowсвойство, но я не думаю, что это имеет значение), которое уже было заполнено предыдущим скриптом, но я не хочу, чтобы другой скрипт запускался позже, чтобы увидеть его значение или что он был даже определены.

Я поставил, some_var = undefinedи это работает с целью тестирования, typeof some_var == "undefined"но я действительно не думаю, что это правильный путь.

Что вы думаете?

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 », и основное отличие заключается в том, что элементы LexicalEvironment являются вложенными - то есть LexicalEnvironment имеет родителя ( то, что спецификация ECMAScript называет «ссылкой на внешнюю среду»), и когда Javscript не удается найти ссылку в LexicalEenvironment , он ищет в родительской среде LexicalEnvironment (как подробно описано в 10.3.1 и 10.2.2.1 ). Верхний уровень LexicalEnvironment - это « глобальная среда»", и это связано с глобальным объектом в том смысле, что его ссылки являются свойствами глобального объекта. Поэтому, если вы попытаетесь получить доступ к имени, которое не было объявлено с использованием varключевого слова в текущей области или каких-либо внешних областях, Javascript в конечном итоге получит свойство от windowобъекта , чтобы служить этой ссылке. Как мы узнали ранее, свойства на объекты могут быть удалены.

Ноты

1. Важно помнить, что varобъявления «подняты», т. Е. Всегда считается, что они произошли в начале области действия, в которой они находятся, - но не при инициализации значения, которое может быть выполнено в varоператоре, - который остается там, где он находится. , Таким образом, в следующем коде aэто ссылка из VariableEnvironment, а не windowсвойство, и его значение будет 10в конце кода:

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

2. Обсуждение выше, когда «строгий режим» не включен. Правила поиска немного отличаются при использовании «строгого режима», и лексические ссылки, которые разрешались бы в свойствах окна без «строгого режима», приводят к ошибкам «необъявленная переменная» в «строгом режиме». Я не совсем понял, где это указано, но как ведут себя браузеры.

Ответ @ scunlife сработает, но технически это должно быть

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
}());

Но поскольку глобальные переменные на самом деле являются членами объекта window, это работает.

Когда задействованы цепочки прототипов, использование 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.

Так что будь осторожен.

РЕДАКТИРОВАТЬ: Мой ответ несколько неточный (см. «Заблуждения» в конце). Ссылка объясняет все кровавые подробности, но в итоге можно сказать, что между браузерами могут быть большие различия в зависимости от объекта, из которого вы удаляете. delete object.somePropкак правило, должны быть в безопасности, пока object !== window. Я все еще не использовал бы это, чтобы удалить переменные, объявленные с, varхотя вы можете при правильных обстоятельствах.

Если вы неявно объявляете переменную без 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

some_var = null;

//or remove it..
delete some_var;

TLDR: просто определенные переменные (без var, let, const) может быть удален с delete. Если вы используете var, let, const- они не могут быть удалены ни с deleteни с 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 показывает то же самое поведение.

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(а также оператор удаления ). В других случаях возвращается 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

Переменные, в отличие от простых свойств, имеют атрибут [[Configurable]] , что означает невозможность удаления переменной с помощью оператора удаления . Однако есть один контекст выполнения, на который это правило не влияет. Это eval context: там атрибут [[Configurable]] не установлен для переменных.

Оператор удаления удаляет свойство из объекта.

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'];

В дополнение к тому, что все написали, также обратите внимание, что deleteвозвращает логическое значение. Он может сказать вам, было ли удаление успешным или нет.

Тестирование на Chrome, все, кроме letудаления. когда deleteвернулся, trueто фактически удалил их:

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

Вы не можете удалить переменную, если вы объявили ее (с помощью var x;) во время первого использования. Однако, если ваша переменная x впервые появилась в скрипте без объявления, вы можете использовать оператор delete (delete x;), и ваша переменная будет удалена, что очень похоже на удаление элемента массива или удаление свойства объекта ,

Я немного смущен. Если все, что вам нужно, это чтобы значение переменной не передавалось в другой сценарий, тогда нет необходимости удалять переменную из области. Просто обнулите переменную, а затем явно проверьте, является ли она нулевой. Зачем переживать проблему удаления переменной из области видимости? С какой целью этот сервер обнулять не может?

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