path: root/files/es/web/javascript/referencia/operadores/delete/index.html

---
title: operador delete
slug: Web/JavaScript/Referencia/Operadores/delete
translation_of: Web/JavaScript/Reference/Operators/delete
---
<div>
<div>{{jsSidebar("Operators")}}</div>
</div>

<h2 id="Resumen">Resumen</h2>

<p>El operador <code>delete</code>  elimina una propiedad de un objeto.</p>

<h2 id="Syntax" name="Syntax">Sintaxis</h2>

<pre class="syntaxbox">delete expresión </pre>

<p>donde la <em>expresión</em> debe evaluar una referencia de la propiedad, por ejemplo:</p>

<pre class="syntaxbox">delete <em>objeto.propiedad</em>
delete <em>objeto</em>['<em>propiedad</em>']
</pre>

<h3 id="Parameters" name="Parameters">Parámetros</h3>

<dl>
 <dt><code>objeto</code></dt>
 <dd>El nombre de un objeto, o una expresión que evalua a un objeto.</dd>
 <dt><code>propiedad</code></dt>
 <dd>La propiedad a eliminar.</dd>
</dl>

<h3 id="Returns" name="Returns">Retorno</h3>

<p>En <a href="/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/Strict_mode">modo estricto</a> arroja una excepción si la propiedad no es configurable (retorna <code>false</code> en modo no estricto). Retorna <code>true</code> en cualquier otro caso.</p>

<h2 id="Description" name="Description">Descripción</h2>

<p>Al contrario de lo que se podría pensar, el operador <code>delete</code> 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<a href="https://developer.mozilla.org/es/docs/Web/JavaScript/Gestion_de_Memoria"> gestión de memoria</a>).</p>

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

<p><code>delete</code> sólo es efectivo en propiedades de objetos. No tiene ningún efecto en variables o en nombres de funciones.<br>
 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.</p>

<p><code>delete</code> 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.</p>

<h3 id="Temporal_dead_zone">Temporal dead zone</h3>

<p>The "<a href="/en-US/docs/Web/JavaScript/Reference/Statements/let#Temporal_dead_zone_and_errors_with_let">temporal dead zone"</a> (TDZ), specified in ECMAScript 6 for <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/const">const</a></code> and <a href="/en-US/docs/Web/JavaScript/Reference/Statements/let"><code>let</code></a> declarations, also applies to the <code>delete</code> operator. Thus, code like the following will throw a {{jsxref("ReferenceError")}}.</p>

<pre class="brush: js">function foo() {
  delete x;
  let x;
}

function bar() {
  delete y;
  const y;
}</pre>

<h2 id="Ejemplos">Ejemplos</h2>

<pre class="brush: js">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
}
</pre>

<p>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.</p>

<p>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.</p>

<pre class="brush: js">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);           </pre>

<h3 id="Deleting_array_elements" name="Deleting_array_elements">Eliminando elementos de un array</h3>

<p>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.</p>

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

<pre class="brush: js">var trees = ["redwood","bay","cedar","oak","maple"];
delete trees[3];
if (3 in trees) {
    // esto no se ejecuta
}</pre>

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

<pre class="brush: js">var trees = ["redwood","bay","cedar","oak","maple"];
trees[3] = undefined;
if (3 in trees) {
    // esto se ejecuta
}</pre>

<h2 id="Especificaciones">Especificaciones</h2>

<table class="standard-table">
 <tbody>
  <tr>
   <th scope="col">Especificación</th>
   <th scope="col">Estado</th>
   <th scope="col">Comentario</th>
  </tr>
  <tr>
   <td>ECMAScript 1st Edition.</td>
   <td>Standard</td>
   <td>Definición inicial. Implementado en JavaScript 1.2</td>
  </tr>
  <tr>
   <td>{{SpecName('ES5.1', '#sec-11.4.1', 'The delete Operator')}}</td>
   <td>{{Spec2('ES5.1')}}</td>
   <td> </td>
  </tr>
  <tr>
   <td>{{SpecName('ES6', '#sec-delete-operator', 'The delete Operator')}}</td>
   <td>{{Spec2('ES6')}}</td>
   <td> </td>
  </tr>
 </tbody>
</table>

<h2 id="Compatibilidad_de_navegador">Compatibilidad de navegador</h2>

<p>{{CompatibilityTable}}</p>

<div id="compat-desktop">
<table class="compat-table">
 <tbody>
  <tr>
   <th>Feature</th>
   <th>Chrome</th>
   <th>Firefox (Gecko)</th>
   <th>Internet Explorer</th>
   <th>Opera</th>
   <th>Safari</th>
  </tr>
  <tr>
   <td>Basic support</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
  </tr>
  <tr>
   <td>Temporal dead zone</td>
   <td>{{CompatUnknown}}</td>
   <td>{{CompatGeckoDesktop(36)}}</td>
   <td>{{CompatUnknown}}</td>
   <td>{{CompatUnknown}}</td>
   <td>{{CompatUnknown}}</td>
  </tr>
 </tbody>
</table>
</div>

<div id="compat-mobile">
<table class="compat-table">
 <tbody>
  <tr>
   <th>Feature</th>
   <th>Android</th>
   <th>Chrome for Android</th>
   <th>Firefox Mobile (Gecko)</th>
   <th>IE Mobile</th>
   <th>Opera Mobile</th>
   <th>Safari Mobile</th>
  </tr>
  <tr>
   <td>Basic support</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
  </tr>
  <tr>
   <td>Temporal dead zone</td>
   <td>{{CompatUnknown}}</td>
   <td>{{CompatUnknown}}</td>
   <td>{{CompatGeckoMobile(36)}}</td>
   <td>{{CompatUnknown}}</td>
   <td>{{CompatUnknown}}</td>
   <td>{{CompatUnknown}}</td>
  </tr>
 </tbody>
</table>
</div>

<h3 id="Cross-browser_issues">Cross-browser issues</h3>

<p>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 <code>delete</code> 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 <em>value</em> is indeed set to undefined, if one later adds back a property with the same name, the property will be iterated in its <em>old</em> position--not at the end of the iteration sequence as one might expect after having deleted the property and then added it back.</p>

<p>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.</p>

<h2 id="See_also" name="See_also">Ver también</h2>

<ul>
 <li><a href="http://perfectionkills.com/understanding-delete/">Análisis en profundidad sobre delete</a></li>
</ul>