¿Cómo desarmar una variable de JavaScript?

Tengo una variable global en JavaScript (en realidad, una windowpropiedad, pero no creo que importe) que ya estaba poblada por un script anterior, pero no quiero otro script que se ejecute más tarde para ver su valor o que incluso definido.

Lo he puesto some_var = undefinedy funciona con el propósito de probarlo, typeof some_var == "undefined"pero realmente no creo que sea la forma correcta de hacerlo.

¿Qué piensas?

El deleteoperador elimina una propiedad de un objeto. No puede eliminar una variable. Entonces, la respuesta a la pregunta depende de cómo se defina la variable o propiedad global.

(1) Si se crea con var, no se puede eliminar.

Por ejemplo:

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) Si se crea sin var, se puede eliminar.

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

Explicación técnica

1. Usando var

En este caso, la referencia g_ase crea en lo que la especificación ECMAScript llama " VariableEnvironment " que se adjunta al alcance actual; este puede ser el contexto de ejecución de una función en el caso de usar vardentro de una función (aunque puede ser un poco más complicado cuando lo considere let) o en el caso del código "global", el entorno variable se adjunta al objeto global (a menudo window).

Las referencias en el entorno Variable normalmente no se pueden eliminar: el proceso detallado en ECMAScript 10.5 explica esto en detalle, pero es suficiente decir que a menos que su código se ejecute en un evalcontexto (que la mayoría de las consolas de desarrollo basadas en navegador usan), entonces las variables declaradas con varno pueden ser eliminado

2. Sin usar var

Al intentar asignar un valor a un nombre sin usar la varpalabra clave, Javascript intenta ubicar la referencia nombrada en lo que la especificación ECMAScript llama " LexicalEnvironment ", y la principal diferencia es que LexicalEvironment s está anidado, es decir, un entorno Lexical tiene un padre ( lo que la especificación ECMAScript llama "referencia de entorno externo") y cuando Javscript no puede localizar la referencia en un entorno Lexical , se ve en el padre entorno Lexical (como se detalla en 10.3.1 y 10.2.2.1 ). El nivel superior de LexicalEnvironment es el " entorno global", y eso está vinculado al objeto global en el sentido de que sus referencias son las propiedades del objeto global. Por lo tanto, si intenta acceder a un nombre que no se declaró utilizando una varpalabra clave en el ámbito actual o cualquier ámbito externo, Javascript finalmente obtendrá una propiedad del windowobjeto para que sirva como referencia. Como hemos aprendido antes, las propiedades de los objetos se pueden eliminar.

Notas

1. Es importante recordar que las vardeclaraciones son "izadas", es decir, siempre se considera que ocurrieron al comienzo del alcance en el que se encuentran, aunque no la inicialización del valor que se puede hacer en una vardeclaración, que se deja donde está. . Entonces, en el siguiente código, aes una referencia del entorno Variable y no elwindow propiedad y su valor estará 10al final del código:

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

2. La discusión anterior es cuando el "modo estricto" no está habilitado. Las reglas de búsqueda son un poco diferentes cuando se utiliza el "modo estricto" y las referencias léxicas que se habrían resuelto a las propiedades de la ventana sin el "modo estricto" generarán errores de "variable no declarada" en el "modo estricto". Realmente no entendí dónde se especifica esto, pero es cómo se comportan los navegadores.

La respuesta de @ scunlife funcionará, pero técnicamente debería ser

delete window.some_var; 

Se supone que eliminar es un no-op cuando el objetivo no es una propiedad de objeto. p.ej,

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

Pero dado que las variables globales son en realidad miembros del objeto de ventana, funciona.

Cuando las cadenas de prototipos están involucradas, el uso de eliminar se vuelve más complejo porque solo elimina la propiedad del objeto de destino, y no el prototipo. p.ej,

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.

Así que ten cuidado.

EDITAR: Mi respuesta es algo inexacta (ver "Conceptos erróneos" al final). El enlace explica todos los detalles sangrientos, pero el resumen es que puede haber grandes diferencias entre los navegadores y dependiendo del objeto desde el que está borrando. delete object.somePropgeneralmente debe ser seguro mientras object !== window. Todavía no lo usaría para eliminar variables declaradas con, varaunque puede hacerlo en las circunstancias correctas.

Si está declarando implícitamente la variable sin var, la forma correcta sería utilizarla delete foo.

Sin embargo, después de eliminarlo, si intenta usar esto en una operación como la adición ReferenceError, se generará un a porque no puede agregar una cadena a un identificador no declarado ni definido. Ejemplo:

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

Puede ser más seguro en algunas situaciones asignarlo a falso, nulo o indefinido para que se declare y no arroje este tipo de error.

foo = false

Nótese que en ECMAScript null, false, undefined, 0, NaN, o ''sería toda evaluar a false. Solo asegúrese de no usar el !==operador, sino que !=cuando escriba la comprobación de booleanos y no desee la comprobación de identidad (también lo nullharía == falsey false == undefined).

También tenga en cuenta que deleteno "elimina" las referencias sino solo las propiedades directamente en el objeto, por ejemplo:

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)

Si ha declarado una variable con varno puede eliminarla:

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

En rinoceronte:

js> var x
js> delete x
false

Tampoco puede eliminar algunas propiedades predefinidas como Math.PI:

js> delete Math.PI
false

Hay algunas excepciones extrañas al deleteigual que con cualquier idioma, si le importa lo suficiente debe leer:

• 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: sencilla define las variables (sin var, let, const) podría suprimirse con delete. Si utiliza var, let, const- no podían ser borrados ni con deleteni con 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 muestra el mismo comportamiento.

ECMAScript 2015 ofrece Reflect API. Es posible eliminar la propiedad del objeto con Reflect.deleteProperty () :

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

Para eliminar la propiedad del windowobjeto global :

Reflect.deleteProperty(window, 'some_var');

En algunos casos, las propiedades no se pueden eliminar (cuando la propiedad no es configurable) y luego se devuelve esta función false(así como eliminar el operador ). En otros casos devuelve 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

Hay una diferencia entre deletePropertyfunción y deleteoperador cuando se ejecuta en modo estricto:

'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

Las variables, en contraste con las propiedades simples, tienen el atributo [[Configurable]] , lo que significa que es imposible eliminar una variable a través del operador de eliminación . Sin embargo, hay un contexto de ejecución en el que esta regla no afecta. Es el contexto de evaluación : el atributo [[Configurable]] no está configurado para variables.

El operador de eliminación elimina una propiedad de un objeto.

delete object.property
delete object['property']

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

Según la pregunta, necesita uno de los siguientes

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

Además de lo que todos habían escrito, también tenga en cuenta que deletedevuelve boolean. Puede decirle si la eliminación fue exitosa o no.

Pruebas en Chrome, todo excepto letdeleltable. cuando deleteregresó, trueen realidad los eliminó:

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

No puede eliminar una variable si la declaró (con var x;) en el momento del primer uso. Sin embargo, si su variable x apareció por primera vez en el script sin una declaración, puede usar el operador delete (delete x;) y su variable se eliminará, muy similar a eliminar un elemento de una matriz o eliminar una propiedad de un objeto .

Estoy un poco confundido Si todo lo que desea es que un valor de variable no pase a otro script, entonces no hay necesidad de eliminar la variable del ámbito. Simplemente anule la variable y luego compruebe explícitamente si es nula o no. ¿Por qué pasar por la molestia de eliminar la variable del alcance? ¿Para qué sirve este servidor que no puede anular?

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