Warum können wir also die Attribute eines Objekts löschen:
var x = { a: 1 };
delete x.a; // true
x.a; // undefinedNach dem Login kopieren
Aber Sie können eine Variable nicht löschen:
var x = 1;
delete x; // false;
x; // 1
Nach dem Login kopieren
Sie können eine Funktion auch nicht löschen:
function x() {};
delete x; // false;
typeof x; // "function"Nach dem Login kopieren
Hinweis: delete gibt nur dann false zurück, wenn eine Eigenschaft nicht gelöscht werden kann.
Jedes Attribut hat null bis mehrere interne Attribute – *ReadOnly, DontEnum, DontDelete und Internal**. Sie können sie sich als Tags vorstellen – eine Eigenschaft kann eine spezielle interne Eigenschaft haben oder auch nicht. Für die heutige Diskussion interessieren wir uns für DontDelete.
Wenn Variablen und Funktionen deklariert werden, werden sie zu Eigenschaften des Variablenobjekts – entweder des Aktivierungsobjekts (im Funktionscode) oder des globalen Objekts (im globalen Code). Diese Eigenschaften werden von der internen Eigenschaft DontDelete begleitet. Explizit/implizit zugewiesene Eigenschaften generieren jedoch kein DontDelete. Und das ist im Wesentlichen der Grund, warum wir einige Eigenschaften löschen können, andere jedoch nicht.
var GLOBAL_OBJECT = this;
Nach dem Login kopieren
/* 'foo' ist eine Eigenschaft des globalen Objekts, das durch Variablendeklaration generiert wird, daher verfügt es über die interne Eigenschaft DontDelete
Deshalb kann es nicht gelöscht werden*/
var foo = 1;
delete foo; // false
typeof foo; // "number"
/* 'bar
Nach dem Login kopieren
' ist eine Eigenschaft des globalen Objekts, das durch Variablendeklaration generiert wird, daher verfügt es über das untergeordnete DontDelete-Objekt
Deshalb kann es auch nicht gelöscht werden*/
function bar() {};
delete bar; // false
typeof bar; // "function"Nach dem Login kopieren
/* 'baz' ist auch eine Eigenschaft des globalen Objekts
Es wird jedoch über die Eigenschaftszuweisung generiert, daher gibt es kein DontDelete
Deshalb kann es entfernt werden*/
GLOBAL_OBJECT.baz = "baz";
delete GLOBAL_OBJECT.baz; // true
typeof GLOBAL_OBJECT.baz; // "undefined"
Nach dem Login kopieren
1.5, integrierte und DontDelete |. Build-ins und DontDelete
Das ist also der Grund, warum das alles passiert: Eine spezielle interne Eigenschaft einer Eigenschaft steuert, ob die Eigenschaft gelöscht werden kann oder nicht. Hinweis: Einige Eigenschaften integrierter Objekte haben die interne Eigenschaft DontDelete und können daher nicht gelöscht werden. Spezielle Argumentvariablen (wie wir wissen, Eigenschaften aktivierter Objekte) haben auch die Eigenschaft „Länge“ (Rückgabeparameterlänge) jeder Funktionsinstanz Nicht löschen:
(function() {
//不能删除'arguments'，因为有DontDelete
delete arguments; // false;
typeof arguments; // "object"
//也不能删除函数的length,因为有DontDelete
function f() {};
delete f.length; // false;
typeof f.length; // "number"
}) ();
Nach dem Login kopieren
Die mit Funktionsargumenten verknüpften Eigenschaften verfügen ebenfalls über DontDelete und können ebenfalls nicht gelöscht werden
(function(foo,bar) {
delete foo; // false
foo; // 1
delete bar; // false
bar; // "bah"
}) (1,"bah");Nach dem Login kopieren
1.6. Nicht deklarierte Variablenzuweisungen |
Sie erinnern sich vielleicht daran, dass eine nicht deklarierte Variablenzuweisung zu einer Eigenschaft des globalen Objekts wird, es sei denn, die Eigenschaft befindet sich an anderer Stelle in der Bereichskette. Und jetzt verstehen wir den Unterschied zwischen Eigenschaftszuweisung und Variablendeklaration – letztere generiert DontDelete und erstere nicht – weshalb nicht deklarierte Variablenzuweisungen gelöscht werden können.
var GLOBAL_OBJECT = this;
/* 通过变量声明生成全局对象的属性，拥有DontDelete */
var foo = 1;
/* 通过未声明的变量赋值生成全局对象的属性，没有DontDelete */
bar = 2;
delete foo; // false
delete bar; // true
Nach dem Login kopieren
Hinweis: Interne Attribute werden bei der Generierung der Attribute bestimmt und nachfolgende Zuweisungsprozesse ändern nicht die internen Attribute vorhandener Attribute. Es ist wichtig, diesen Unterschied zu verstehen.
/* 'foo'创建的同时生成DontDelete */
function foo() {};
/* 之后的赋值过程不改变已有属性的内部属性，DontDelete仍然存在 */
foo = 1;
delete foo; // false;
typeof foo; // "number"
/* 但赋值一个不存在的属性时，创建了一个没有内部属性的属性，因此没有DontDelete */
this.bar = 1;
delete bar; // true;
typeof bar; // "undefined"Nach dem Login kopieren
Zusammenfassung:
Variablen- und Funktionsdeklarationen sind Eigenschaften des globalen Aktivierungsobjekts.
Eigenschaften verfügen über interne Eigenschaften, von denen eine – DontDelete – dafür verantwortlich ist, zu bestimmen, ob eine Eigenschaft gelöscht werden kann.
Variablen und Funktionsdeklarationen im globalen Code oder Funktionscode generieren alle Attribute mit DontDelete.
Funktionsparameter sind ebenfalls Attribute des Aktivierungsobjekts und haben auch DontDelete.
Attribute im Objekt löschen: delete object.member
Sie können nur Ihre eigenen Mitglieder löschen
Nur mit var deklarierte globale Variablen können nicht gelöscht werden
Globale Mitglieder, die mit window oder window[""] hinzugefügt wurden, können gelöscht werden
ps: Löschoperator in Javascript
Löschen ist einer der weniger häufig verwendeten Vorgänge in der Javascript-Sprache, aber manchmal, wenn wir Lösch- oder Löschaktionen ausführen müssen, benötigen wir den Löschvorgang. In diesem Artikel befassen wir uns mit der Verwendung und Funktionsweise.
Der Zweck des Löschens besteht Ihrer Meinung nach darin, etwas zu löschen. Genauer gesagt werden die Attribute des Objekts gelöscht, wie im folgenden Beispiel:
Der Löschoperator
var Benjamin = {
"name": "zuojj",
"url" : "http://www.zuojj.com"
};
delete Benjamin.name;
//Outputs: Object { url: "http://www.zuojj.com" }
console.log(Benjamin);Nach dem Login kopieren
löscht keine gewöhnlichen Variablen, wie im folgenden Beispiel:
var benjamin = "http://www.zuojj.com";
delete benjamin;
//Outputs: "http://www.zuojj.com"
console.log(benjamin);
Nach dem Login kopieren
Allerdings können „globale Variablen“ entfernt werden, da es sich tatsächlich um Eigenschaften des globalen Objekts (Fenster in Browsern) handelt.
Der
// Because var isn't used, this is a property of window
benjamin = "zuojj";
delete window.benjamin;
// ReferenceError: benjamin is not defined
console.log(benjamin);
Nach dem Login kopieren
delete-Operator hat auch einen Rückgabewert. Wenn das Löschen eines Attributs erfolgreich ist, gibt er „true“ zurück. Wenn das Attribut nicht gelöscht werden kann, weil das Attribut nicht beschreibbar ist, wird „false“ zurückgegeben, oder es wird ein Fehler ausgegeben strenger Modus.
你可能不知道在什么情况下使用删除运算符。答案是，只要你真的想从对象中删除一个属性。
有的时候，Javascript开发不是删除一个属性，而是把这个属性值设置为null.像下面这样：
var benjamin = {
"name": "zuojj",
"url" : "http://www.zuojj.com"
};
benjamin.name = null;Nach dem Login kopieren
虽然这有效地切断从原来的值的属性，但该属性本身仍然存在的对象上，你可以看到如下：
// Outputs: Object { name: null, url: "http://www.zuojj.com" }
console.log(benjamin);Nach dem Login kopieren
同时，像in和for in 循环运算将不会报告null属性的存在，如果你使用个对象，可能使用这些方法来检查一个对象，你可能想确保你真正删除任何不需要的属性。
最后，你应该记住，删除并没有破坏属性的值，仅仅属性本身，看下面的例子：
var name = "zuojj",
benjamin = {};
benjamin.name = name;
delete benjamin.name;
//Outputs: "zuojj"
console.log(name);Nach dem Login kopieren
这里，name和benjamin.name映射到相同的值，真如你所看到的，删除benjamin.name并不会影响name.
以上，就是我对delete运算符的概述，不妥之处，欢迎大家批评指正。
