delete operator

  • Revision slug: JavaScript/Reference/Operators/delete
  • Revision title: delete
  • Revision id: 293011
  • Created:
  • Creator: ethertank
  • Is current revision? No
  • Comment

Revision Content

Summary

The delete operator removes a property from an object.

Operator
Implemented in: JavaScript 1.2
ECMAScript Edition: ECMA-262 1st Edition

Syntax

delete expression

where expression should evaluate to a property reference, e.g.:

delete variableName
delete objectExpression.property
delete objectExpression["property"]
delete objectExpression[index]
delete property // legal only within a with statement

If expression does not evaluate to a property, delete does nothing.

Parameters

objectName
The name of an object.
property
The property to delete.
index
An integer representing the array index to delete.

Returns

Returns false only if the property exists and cannot be deleted. It returns true in all other cases.

Description

The fifth form is legal only within a with statement, to delete a property from an object.

You can use the delete operator to delete variables declared implicitly but not those declared with the var or the function statement.

If the delete operator succeeds, it removes the property from the object entirely, although this might reveal a similarly named property on a prototype of the object.

Some object properties cannot be deleted. In the ECMA 262 specification these are marked as DontDelete.

x = 42;        // assigns as property of global object
var y = 43;    // declares as variable
myobj = new Number();
myobj.h = 4;    // create property h
myobj.k = 5;    // create property k

delete x;       // returns true (can delete if declared implicitly)
delete y;       // returns false (cannot delete if declared with var, property is DontDelete)
delete Math.PI; // returns false (cannot delete most predefined properties, declared DontDelete)
delete myobj.h; // returns true (can delete user-defined properties)
with(myobj) { 
  delete k;    // returns true (equivalent to delete myobj.k)
} 
delete myobj;   // returns true (can delete if declared implicitly, equivalent to x)

You cannot delete a property on an object that it inherits from a prototype (although you can delete it directly on the prototype).

 function Foo(){}
 Foo.prototype.bar = 42;
 var foo = new Foo();
 delete foo.bar;           // but doesn't do anything
 alert(foo.bar);           // alerts 42, property inherited
 delete Foo.prototype.bar; // deletes property on prototype
 alert(foo.bar);           // alerts "undefined", property no longer inherited

Deleting array elements

When you delete an array element, the array length is not affected. For example, if you delete a{{ mediawiki.external(3) }}, a{{ mediawiki.external(4) }} is still a{{ mediawiki.external(4) }} and a{{ mediawiki.external(3) }} is undefined. This holds even if you delete the last element of the array (delete a{{ mediawiki.external('a.length-1') }}).

When the delete operator removes an array element, that element is no longer in the array. In the following example, trees{{ mediawiki.external(3) }} is removed with delete.

var trees = ["redwood","bay","cedar","oak","maple"];
delete trees[3];
if (3 in trees) {
   // this does not get executed
}

If you want an array element to exist but have an undefined value, use the undefined value instead of the delete operator. In the following example, trees{{ mediawiki.external(3) }} is assigned the value undefined, but the array element still exists:

var trees = ["redwood","bay","cedar","oak","maple"];
trees[3]=undefined;
if (3 in trees) {
   // this gets executed
}

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.

Revision Source

<h2 id="Summary">Summary</h2>
<p>The <code>delete</code> operator removes a property from an object.</p>
<table class="standard-table">
  <thead>
    <tr>
      <th class="header" colspan="2" scope="row">Operator</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Implemented in:</td>
      <td>JavaScript 1.2</td>
    </tr>
    <tr>
      <td>ECMAScript Edition:</td>
      <td>ECMA-262 1st Edition</td>
    </tr>
  </tbody>
</table>




<h2 id="Syntax">Syntax</h2>
<p><code>delete <em>expression</em></code></p>
<p>where <em>expression</em> should evaluate to a property reference, e.g.:</p>
<pre class="eval">
delete <em>variableName</em>
delete <em>objectExpression.property</em>
delete <em>objectExpression</em>["<em>property</em>"]
delete <em>objectExpression</em>[<em>index</em>]
delete <em>property</em> // legal only within a with statement
</pre>

<p>If <em>expression</em> does not evaluate to a property, <code>delete</code> does nothing.</p>



<h2 id="Parameters">Parameters</h2>
<dl>
  <dt>
    <code>objectName</code></dt>
  <dd>
    The name of an object.</dd>
</dl>
<dl>
  <dt>
    <code>property</code></dt>
  <dd>
    The property to delete.</dd>
</dl>
<dl>
  <dt>
    <code>index</code></dt>
  <dd>
    An integer representing the array index to delete.</dd>
</dl>



<h2 id="Returns">Returns</h2>
<p>Returns false only if the property exists and cannot be deleted. It returns true in all other cases.</p>



<h2 id="Description">Description</h2>
<p>The fifth form is legal only within a <code>with</code> statement, to delete a property from an object.</p>
<p>You can use the <code>delete</code> operator to delete variables declared implicitly but not those declared with the <code>var</code> or the <code>function</code> statement.</p>
<p>If the <code>delete</code> operator succeeds, it removes the property from the object entirely, although this might reveal a similarly named property on a prototype of the object.</p>
<p>Some object properties cannot be deleted. In the ECMA 262 specification these are marked as <em>DontDelete</em>.</p>
<pre class="brush: js">
x = 42;        // assigns as property of global object
var y = 43;    // declares as variable
myobj = new Number();
myobj.h = 4;    // create property h
myobj.k = 5;    // create property k

delete x;       // returns true (can delete if declared implicitly)
delete y;       // returns false (cannot delete if declared with var, property is DontDelete)
delete Math.PI; // returns false (cannot delete most predefined properties, declared DontDelete)
delete myobj.h; // returns true (can delete user-defined properties)
with(myobj) { 
  delete k;    // returns true (equivalent to delete myobj.k)
} 
delete myobj;   // returns true (can delete if declared implicitly, equivalent to x)
</pre>
<p>You cannot delete a property on an object that it inherits from a prototype (although you can delete it directly on the prototype).</p>
<pre class="brush: js">
 function Foo(){}
 Foo.prototype.bar = 42;
 var foo = new Foo();
 delete foo.bar;           // but doesn't do anything
 alert(foo.bar);           // alerts 42, property inherited
 delete Foo.prototype.bar; // deletes property on prototype
 alert(foo.bar);           // alerts "undefined", property no longer inherited
</pre>


<h3 id="Deleting_array_elements">Deleting array elements</h3>
<p>When you delete an array element, the array length is not affected. For example, if you delete a{{ mediawiki.external(3) }}, a{{ mediawiki.external(4) }} is still a{{ mediawiki.external(4) }} and a{{ mediawiki.external(3) }} is undefined. This holds even if you delete the last element of the array (<code>delete a{{ mediawiki.external('a.length-1') }}</code>).</p>
<p>When the <code>delete</code> operator removes an array element, that element is no longer in the array. In the following example, trees{{ mediawiki.external(3) }} is removed with <code>delete</code>.</p>
<pre class="brush: js">
var trees = ["redwood","bay","cedar","oak","maple"];
delete trees[3];
if (3 in trees) {
   // this does not get executed
}
</pre>
<p>If you want an array element to exist but have an undefined value, use the <code>undefined</code> value instead of the <code>delete</code> operator. In the following example, trees{{ mediawiki.external(3) }} is assigned the value undefined, but the array element still exists:</p>
<pre class="brush: js">
var trees = ["redwood","bay","cedar","oak","maple"];
trees[3]=undefined;
if (3 in trees) {
   // this gets executed
}
</pre>



<h2 id="Cross-browser_issues">Cross-browser issues</h2>
<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>
Revert to this revision