In ES3, delete is introduced in 8.6.2.5 and 11.4.1, as follows
There is 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 code as follows:
function func() {
delete arguments;
alert(arguments);
}
func(1);
2. Variable declaration (10.2.1)
Copy the code code as follows:
var a = 10;
delete a;
alert(a); // 10
This item is mentioned in many JS books, that is, variables declared using var cannot be deleted.
3. Function declaration
Copy the code code as follows:
function func() {}
delete func;
alert(func); // func code
4. The length attribute of the function
Copy the code code as follows:
function func(a, b) {}
delete func.length;
alert(func.length); // 2
5. Some constants (NaN, Infinity, undefined)
Copy the code code as follows:
delete NaN; // false
delete Infinity; // false
delete undefined; // false
6. Prototype of built-in constructor
Copy the code code 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. The length of arrays and strings
Copy the code code 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 the code code as follows:
delete Math.E; // false
...
9. Properties of regular objects (source, global, ignoreCase, multiline, lastIndex)
Copy the code code 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 nine points listed above are described in ES5 as [[Configurable]] is false.
The new Object.defineProperty method in ES5 can display the Configurable of the defined object, as follows
Copy the code code as follows:
var obj = {name: 'John'};
Object.defineProperty(obj, "key", {
configurable: false,
value: "static"
});
delete obj.name; // true
delete obj.key // false
The 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. like
Copy the code code as follows:
"use strict";
delete Object.prototype;
The console error in FF is as follows:
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 an object that inherits properties from the prototype.
Copy the code code 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 code 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 the code code as follows:
delete Person.prototype.name
To summarize:
1. Most properties and methods of built-in objects cannot be deleted (although some can be deleted, such as isNaN and 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."