Оператор 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 - это < em> global environment, и это связано с глобальным объектом в том смысле, что его ссылки являются свойствами глобального объекта. Поэтому, если вы попытаетесь получить доступ к имени, которое не было объявлено с использованием ключевого слова 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
}());

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

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

В Rhino:

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

Отредактировано обновлено, чтобы прояснить различные варианты (в зависимости от ваших желаемых намерений)

См. Ответ @noah для получения полной информации.

//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;

Использованная литература:

API удаления MDN

MDN SyntaxError при удалении неквалифицированного имени переменной в строгом синтаксисе режим

TL; DR: простые определенные переменные (без 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]], что означает невозможность удаления переменной с помощью оператора delete. Однако есть один контекст выполнения, на который это правило не влияет. Это контекст eval: там атрибут [[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'];

⚠️ Принятый (и другие) ответ устарел!

TL;DR

• delete не не удалить переменные.
  (Только для удаления свойства из объекта.)

• Правильный способ отключить - просто установить для переменной значение null. _{(источник)}
  (Это позволяет автоматическим процессам JavaScript удалять переменную из памяти.)

x = null;