Parsing objects that cannot be deleted by the delete operator in JavaScript_javascript tips

In ES3, delete is introduced in 8.6.2.5 and 11.4.1, as follows

Have some information,

1. The delete operator in the implementation will call the [[Delete]] method inside the engine

2. [[Delete]] is defined in 8.6.2

3. The deleted attribute has the DontDelete feature. If so, false will be returned directly when deleting

Search for "DontDelete" and you will find many. None of the following can be deleted

1, activate the arguments object of the object (10.1.6)

Copy the code The code is as follows:

function func() {
delete arguments;
alert(arguments);
}
func(1);

2, variable declaration (10.2. 1)

Copy code The code is as follows:

var a = 10;
delete a ;
alert(a); // 10

This article is mentioned in many JS books, that is, variables declared using var cannot be deleted.

3, function declaration

Copy code The code is as follows:

function func() { }
delete func;
alert(func); // func code

4, the length attribute of the function

copy Code The code is as follows:

function func(a, b) {}
delete func.length;
alert(func.length); / / 2

5, some constants (NaN, Infinity, undefined)

Copy code The code is as follows :

delete NaN; // false
delete Infinity; // false
delete undefined; // false

6, prototype of the built-in constructor

Copy code The code is as follows:

delete Object.prototype; // false
delete Function.prototype; // false
delete Array.prototype; // false
delete ExpReg.prototype; // false
delete Date.prototype; // false
delete Error.prototype; // false
delete Number.prototype; // false
delete Boolean.prototype; // false
delete String.prototype; // false

7, for arrays and strings length

Copy code The code is as follows:

var arr = [], str = 'hello' ;
delete arr.length; // false
delete str.length; // false

8, properties of Math object (Math.E, Math.LN10, Math.LN2 , Math.LOG2E, Math.LOG10E, Math.PI, Math.SQRT1_2, Math.SQRT2)

Copy code The code is as follows:

delete Math.E; // false
...

9, properties of regular objects (source, global, ignoreCase, multiline, lastIndex)

Copy code The code is as follows:

var reg = /ss/;
delete reg. source; // false
...

ES5 is different from ES3. There is no "DontDelete" in ES5, but [[Configurable]] (8.6.1) is added.

If the value is false, it cannot be deleted. The 9 points listed above are described in ES5 as [[Configurable]] is false.

ES5’s new Object.defineProperty method can display the Configurable of the defined object, as follows

Copy the code The code is as follows:

var obj = {name: 'John'};
Object.defineProperty(obj, "key", {
configurable: false,
value: "static"
});
delete obj.name; // true
delete obj.key // false

Object obj has name and key. The name can be deleted, but the key cannot.

In addition, in ES5 strict mode, an exception will be thrown directly when deleting an object whose configuable is false. For example,

Copy code The code is as follows:

"use strict";
delete Object. prototype;

The console in FF reports the following error

In addition to some methods or properties of built-in objects that cannot be deleted, there are also custom objects that cannot be deleted. For example, delete cannot delete the properties inherited from the prototype

Copy code The code is as follows:

function Person() {}
Person.prototype.name = 'John Backus';
var p = new Person();
delete p.name;
console.log(p.name); // Still output John Backus

If there is a name on this and prototype, then after delete, the prototype will be displayed

Copy the code The code is as follows:

function Person() {
this.name = 'John Backus';
}
Person.prototype .name = 'John Resig';
var p = new Person();
console.log(p.name); // John Backus
delete p.name;
console.log( p.name); // John Resig, from prototype

If you have to delete the name on the prototype, you can only

Copy code The code is as follows:

delete Person.prototype.name

In summary:

1. Most properties and methods of built-in objects cannot be deleted (although some can be deleted, such as isNaN, parseInt)

2. The properties and methods that an object inherits from the prototype cannot be deleted

The reason is also very simple,

1. Most of the properties and methods of built-in objects cannot be deleted to protect the core API of the language. Once these APIs are deleted, they are basically useless. Such as delete Object.prototype.

2. The attributes and methods that an object inherits from the prototype cannot be deleted to protect the prototype. Otherwise, "if an object of class A deletes an attribute on the prototype, then all objects inherited from A will lose the attribute."