operador delete

Resumen

El operador delete  elimina una propiedad de un objeto.

Sintaxis

delete expresión 

donde la expresión debe evaluar una referencia de la propiedad, por ejemplo:

delete objeto.propiedad
delete objeto['propiedad']

Parámetros

objeto

El nombre de un objeto, o una expresión que evalua a un objeto.

propiedad

La propiedad a eliminar.

Retorno

En modo estricto arroja una excepción si la propiedad no es configurable (retorna false en modo no estricto). Retorna true en cualquier otro caso.

Descripción

Al contrario de lo que se podría pensar, el operador delete no tiene nada que ver con liberar memoria (sólo lo hace de manera indirecta eliminando referencias. Más detalles en la página de gestión de memoria).

Si la operación delete funciona correctamente, eliminará la propiedad del objeto por completo. Sin embargo, si existe otra propiedad con el mismo nombre en la cadena del prototype del objeto, éste heredará la propiedad del prototype.

delete sólo es efectivo en propiedades de objetos. No tiene ningún efecto en variables o en nombres de funciones.
Aunque a veces son mal identificados como variables globales, las asignaciones que no especifican al objeto (ejemplo: x = 5), son en realidad propiedades que se asignan al objeto global.

delete no puede eliminar ciertas propiedades de los objetos predefinidos (como Object, Array, Math etc). Estos están descritos en ECMAScript 5 y más tarde como no configurables.

Temporal dead zone

The "temporal dead zone" (TDZ), specified in ECMAScript 6 for const and let declarations, also applies to the delete operator. Thus, code like the following will throw a ReferenceError.

function foo() { 
  delete x;
  let x;
}

function bar() { 
  delete y; 
  const y; 
}

Ejemplos

x = 42;         // crea la propiedad x en el objeto global
var y = 43;     // crea la propiedad y en el objeto global, y la marca como no configurable
myobj = {
  h: 4,
  k: 5
};

// x es una propiedad del objeto global y puede ser eliminada
delete x;       // retorna true

// y no es configurable, por lo tanto no puede ser eliminada
delete y;       // retorna false

// delete no afecta a ciertas propiedades predefinidas
delete Math.PI; // retorna false

// las propiedades definidas por el usuario pueden eliminarse
delete myobj.h; // retorna true 

// myobj es una propiedad del objeto global, no una variable,
// por lo tanto puede eliminarse
delete myobj;   // retorna true

function f() {
  var z = 44;

  // delete no afecta a nombres de variables locales
  delete z;     // retorna false
}

Si el objeto hereda una propiedad de un prototype, y no tiene la propiedad en sí, la propiedad no puede ser eliminada por referencia al objeto. Aun así, puedes eliminarla directamente en el prototype.

If the object inherits a property from a prototype, and doesn't have the property itself, the property can't be deleted by referencing the object. You can, however, delete it directly on the prototype.

function Foo(){}
Foo.prototype.bar = 42;
var foo = new Foo();

// retorna true, pero sin ningún efecto, 
// ya que bar es una propiedad heredada
delete foo.bar;           

// logs 42, propiedad aún heredada
console.log(foo.bar);

// elimina la propiedad en el prototype
delete Foo.prototype.bar; 

// logs "undefined", propiedad no heredada
console.log(foo.bar);           

Eliminando elementos de un array

Cuando eliminas un elemento de un array, la longitud del array no se ve afectada. Esta se mantiene incluso si eliminas el último elemento del array.

Cuando el operador delete elimina un elemento de un array, este elemento ya no está en el array. En el siguiente ejemplo, trees[3] es eliminado mediante delete.

var trees = ["redwood","bay","cedar","oak","maple"];
delete trees[3];
if (3 in trees) {
    // esto no se ejecuta
}

Si quieres que exista un elemento de un array pero que tengo un valor no definido, utiliza el valor undefined en vez del operador delete. En el siguiente ejemplo, trees[3] es asignado con el valor undefined, pero el elemento del array aún existe:

var trees = ["redwood","bay","cedar","oak","maple"];
trees[3] = undefined;
if (3 in trees) {
    // esto se ejecuta
}

Especificaciones

Compatibilidad de navegador

Cross-browser issues

Although ECMAScript makes iteration order of objects implementation-dependent, it may appear that all major browsers support an iteration order based on the earliest added property coming first (at least for properties not on the prototype). However, in the case of Internet Explorer, when one uses delete on a property, some confusing behavior results, preventing other browsers from using simple objects like object literals as ordered associative arrays. In Explorer, while the property value is indeed set to undefined, if one later adds back a property with the same name, the property will be iterated in its old position--not at the end of the iteration sequence as one might expect after having deleted the property and then added it back.

So, if you want to simulate an ordered associative array in a cross-browser environment, you are forced to either use two separate arrays (one for the keys and the other for the values), or build an array of single-property objects, etc.

Ver también

• Análisis en profundidad sobre delete