Como desmarcar uma variável JavaScript?

Eu tenho uma variável global em JavaScript (na verdade uma windowpropriedade, mas acho que não importa) que já foi preenchida por um script anterior, mas não quero outro script que seja executado mais tarde para ver seu valor ou até mesmo definiram.

Eu coloquei some_var = undefinede funciona com a finalidade de testar, typeof some_var == "undefined"mas realmente não acho que seja o caminho certo a fazer.

O que você acha?

O deleteoperador remove uma propriedade de um objeto. Não pode remover uma variável. Portanto, a resposta para a pergunta depende de como a variável ou propriedade global é definida.

(1) Se for criado com var, não poderá ser excluído.

Por exemplo:

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) Se for criado sem var, poderá ser excluído.

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

Explicação técnica

1. Usando var

Nesse caso, a referência g_aé criada no que a especificação ECMAScript chama de " VariableEnvironment " anexada ao escopo atual - este pode ser o contexto de execução de uma função no caso de usar vardentro de uma função (embora possa ser um pouco mais complicado quando você considera let) ou no caso de código "global", o VariableEnvironment é anexado ao objeto global (geralmente window).

Referências no VariableEnvironment normalmente não são deletable - o processo detalhado no ECMAScript 10,5 explica isso em detalhes, mas basta dizer que a menos que o código é executado em um evalcontexto (que a maioria dos consoles de desenvolvimento baseados em navegador usar), então as variáveis declaradas com varnão pode ser excluído.

2. Sem usar var

Ao tentar atribuir um valor a um nome sem usar a varpalavra - chave, o Javascript tenta localizar a referência nomeada no que a especificação ECMAScript chama de " LexicalEnvironment " e a principal diferença é que LexicalEvironment está aninhado - ou seja, um LexicalEnvironment tem um pai ( o que a especificação ECMAScript chama de "referência do ambiente externo") e quando o Javscript falha ao localizar a referência em um LexicalEenvironment , ele procura no LexicalEnvironment pai (conforme detalhado em 10.3.1 e 10.2.2.1 ). O LexicalEnvironment de nível superior é o " ambiente global", e que está vinculado ao objeto global, em que suas referências são as propriedades do objeto global. Portanto, se você tentar acessar um nome que não foi declarado usando uma varpalavra - chave no escopo atual ou em qualquer escopo externo, o Javascript eventualmente buscará uma propriedade do windowobjeto para servir como essa referência.Como aprendemos antes, as propriedades dos objetos podem ser excluídas.

Notas

1. É importante lembrar que as vardeclarações são "içadas" - isto é, sempre são consideradas como ocorridas no início do escopo em que estão - embora não seja a inicialização de valor que pode ser feita em uma varinstrução - que é deixada onde está. . Portanto, no código a seguir, aé uma referência do VariableEnvironment e não a windowpropriedade e seu valor estará 10no final do código:

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

2. A discussão acima é quando o "modo estrito" não está ativado. As regras de pesquisa são um pouco diferentes ao usar o "modo estrito" e as referências lexicais que teriam resolvido as propriedades da janela sem o "modo estrito" gerarão erros "variáveis ​​não declaradas" em "modo estrito". Eu realmente não entendi onde isso é especificado, mas é como os navegadores se comportam.

A resposta da @ scunlife funcionará, mas tecnicamente deve ser

delete window.some_var; 

delete é suposto não funcionar quando o destino não é uma propriedade de objeto. por exemplo,

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

Mas como as variáveis ​​globais são na verdade membros do objeto window, ele funciona.

Quando cadeias de protótipos estão envolvidas, o uso de delete fica mais complexo, pois remove apenas a propriedade do objeto de destino, e não o protótipo. por exemplo,

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.

Por isso tem cuidado.

EDIT: Minha resposta é um pouco imprecisa (consulte "Conceitos errados " no final). O link explica todos os detalhes sangrentos, mas o resumo é que pode haver grandes diferenças entre os navegadores e dependendo do objeto do qual você está excluindo. delete object.somePropgeralmente deve ser seguro enquanto object !== window. Eu ainda não o usaria para excluir variáveis ​​declaradas com, varembora você possa, nas circunstâncias certas.

Se você estiver declarando implicitamente a variável sem var, a maneira correta seria usar delete foo.

No entanto, após a exclusão, se você tentar usá-lo em uma operação como a adição a ReferenceError, será lançada porque você não pode adicionar uma string a um identificador não declarado e indefinido. Exemplo:

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

Em algumas situações, pode ser mais seguro atribuí-lo a falso, nulo ou indefinido, para que seja declarado e não gerará esse tipo de erro.

foo = false

Note que no ECMAScript null, false, undefined, 0, NaN, ou ''que todos avaliar a false. Apenas certifique-se de não usar o !==operador; em vez disso, !=ao digitar booleanos e não desejar a verificação de identidade (o nullfaria == falseefalse == undefined ).

Observe também que deletenão "exclui" referências, mas apenas propriedades diretamente no objeto, por exemplo:

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)

Se você declarou uma variável com, varnão pode excluí-la:

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

No Rhino:

js> var x
js> delete x
false

Também não é possível excluir algumas propriedades predefinidas, como Math.PI:

js> delete Math.PI
false

Existem algumas exceções estranhas a deletequalquer idioma, se você se importa o suficiente, você deve ler:

• 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: simples definido variáveis (sem var, let, const) poderia ser suprimida com delete. Se você usar var, let, const- não podiam ser apagados nem com deletenem com 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 mostra o mesmo comportamento.

O ECMAScript 2015 oferece a API Reflect. É possível excluir a propriedade do objeto com Reflect.deleteProperty () :

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

Para excluir a propriedade do windowobjeto global :

Reflect.deleteProperty(window, 'some_var');

Em alguns casos, as propriedades não podem ser excluídas (quando a propriedade não é configurável) e, em seguida, essa função retorna false(assim como o operador delete ). Em outros casos, retornos 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

Há uma diferença entre deletePropertyfunção e deleteoperador quando executada no modo estrito:

'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

Variáveis, em contraste com propriedades simples, têm o atributo [[Configurable]] , significando impossibilidade de remover uma variável através do operador delete . No entanto, há um contexto de execução no qual esta regra não afeta. É o contexto eval : o atributo [[Configurable]] não está definido para variáveis.

O operador de exclusão remove uma propriedade de um objeto.

delete object.property
delete object['property']

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

De acordo com a pergunta, você precisa de um dos seguintes

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

Além do que todos haviam escrito, observe também que delete retorna booleano. Pode dizer se a exclusão foi bem-sucedida ou não.

Testando no Chrome, tudo exceto letfoi delicioso. quando deleteretornado true, na verdade os removeu:

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

Você não pode excluir uma variável se a declarar (com var x;) no momento do primeiro uso. No entanto, se sua variável x apareceu pela primeira vez no script sem uma declaração, você pode usar o operador delete (delete x;) e sua variável será excluída, muito semelhante a excluir um elemento de uma matriz ou excluir uma propriedade de um objeto .

Estou um pouco confuso. Se tudo o que você deseja é que um valor de variável não passe para outro script, não há necessidade de excluir a variável do escopo. Simplesmente anule a variável e verifique explicitamente se é ou não nula. Por que enfrentar o problema de excluir a variável do escopo? Que finalidade esse servidor que anula não pode?

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