Was sind Lösch- und Löschoperatoren in js? Und Anwendungsbeispielanalyse

Jede Eigenschaft hat null bis mehrere interne Eigenschaften – *ReadOnly, DontEnum, DontDelete und Internal**. Sie können sie sich wie 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 Variablenobjekten – entweder Aktivierungsobjekten (im Funktionscode) oder globalen Objekten (im globalen Code) – Attribute, diese Attribute werden vom internen Attribut 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;

/* 'foo' ist eine Eigenschaft des globalen Objekts, das durch Variablendeklaration generiert wird, daher hat es die interne Eigenschaft DontDelete

Deshalb kann es nicht gelöscht werden*/

var foo = 1;
delete foo; // false
typeof foo; // "number"
/* 'bar

' ist eine Eigenschaft des globalen Objekts, die durch Variablendeklaration generiert wird , und hat daher das DontDelete-Sub

Deshalb kann es auch nicht gelöscht werden*/

function bar() {};
delete bar; // false
typeof bar; // "function"

/* 'baz' ist ebenfalls eine globale Objekteigenschaft,

Allerdings wird sie durch Eigenschaftszuweisung generiert, daher gibt es kein DontDelete

, weshalb sie gelöscht werden kann* /

GLOBAL_OBJECT.baz = "baz";
delete GLOBAL_OBJECT.baz; // true
typeof GLOBAL_OBJECT.baz; // "undefined"

Build-ins und DontDelete Property steuert, ob die Eigenschaft gelöscht werden kann. 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 length (Rückgabeparameterlänge) jeder Funktionsinstanz DontDelete:

Die mit Funktionsargumenten verknüpften Eigenschaften verfügen ebenfalls über DontDelete und können auch nicht gelöscht werden

(function() {
  //不能删除'arguments'，因为有DontDelete
  delete arguments; // false;
  typeof arguments; // "object"
  //也不能删除函数的length,因为有DontDelete
  function f() {};
  delete f.length; // false;
  typeof f.length; // "number"
}) ();

Nicht deklarierte Variablenzuweisungen|. Nicht deklarierte Variablenzuweisungen

(function(foo,bar) {
  delete foo; // false
  foo; // 1
  delete bar; // false
  bar; // "bah"
}) (1,"bah");

Sie erinnern sich vielleicht, dass nicht deklarierte Variablenzuweisungen zu Eigenschaften des globalen Objekts werden, es sei denn, diese Eigenschaft befindet sich innerhalb der Bereichskette und wurde an anderer Stelle gefunden. 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.

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.

var GLOBAL_OBJECT = this;

/* 通过变量声明生成全局对象的属性，拥有DontDelete */
var foo = 1;

/* 通过未声明的变量赋值生成全局对象的属性，没有DontDelete */
bar = 2;
delete foo; // false
delete bar; // true

Zusammenfassung:

/* 'foo'创建的同时生成DontDelete */
function foo() {};
/* 之后的赋值过程不改变已有属性的内部属性，DontDelete仍然存在 */
foo = 1;
delete foo; // false;
typeof foo; // "number"
/* 但赋值一个不存在的属性时，创建了一个没有内部属性的属性，因此没有DontDelete */
this.bar = 1;
delete bar; // true;
typeof bar; // "undefined"

Variablen- und Funktionsdeklarationen sind Attribute des globalen Aktivierungsobjekts.

Eigenschaften haben 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.Members

Sie können nur Ihre eigenen Mitglieder löschen

Nur globale Variablen, die von var deklariert werden, dürfen nicht gelöscht werden

                                                                                                                                                                                                                              Fenster verwenden Einer der weniger häufig verwendeten Vorgänge, aber manchmal, wenn wir eine Lösch- oder Löschaktion durchführen müssen, benötigen wir einen 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:

Delete-Operator löscht keine normalen Variablen, wie im folgenden Beispiel:

Er kann jedoch „globale Variablen“ löschen, weil sie sind in der Tat Es ist eine Eigenschaft des globalen Objekts (Fenster im Browser).

var Benjamin = {
  "name": "zuojj",
  "url" : "http://www.php.cn"
};
delete Benjamin.name;
//Outputs: Object { url: "http://www.php.cn" }
console.log(Benjamin);

Der Löschoperator 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 Wenn der Wert nicht beschreibbar ist, wird „false“ zurückgegeben, oder im strikten Modus wird ein Fehler ausgegeben.

var benjamin = "http://www.php.cn";
delete benjamin;
//Outputs: "http://www.php.cn"
console.log(benjamin);

Möglicherweise wissen Sie nicht, wann Sie den Löschoperator verwenden sollen. Die Antwort lautet: Wann immer Sie wirklich eine Eigenschaft von einem Objekt entfernen möchten.

Manchmal löscht die Javascript-Entwicklung ein Attribut nicht, sondern setzt den Attributwert auf null, wie folgt:

// Because var isn't used, this is a property of window
benjamin = "php";
delete window.benjamin;
// ReferenceError: benjamin is not defined
console.log(benjamin);

Obwohl dies effektiv schneidet Die Immobilie wird von ihrem ursprünglichen Wert abgezogen, die Immobilie selbst existiert jedoch immer noch auf dem Objekt, wie Sie unten sehen können:

var benjamin = {
  "name": "zuojj",
  "url" : "http://www.php.cn"
};
var nameDeleted = delete benjamin.name;
// Outputs: true
console.log(nameDeleted);
"use strict";
var benjamin_ = "zuojj";
//Outputs: Uncaught SyntaxError: Delete of an unqualified identifier in strict mode.
delete benjamin_;

// Outputs: Object { name: null, url: "http://www.php.cn" }
console.log(benjamin);

同时，像in和for in 循环运算将不会报告null属性的存在，如果你使用个对象，可能使用这些方法来检查一个对象，你可能想确保你真正删除任何不需要的属性。

最后，你应该记住，删除并没有破坏属性的值，仅仅属性本身，看下面的例子：

var name   = "zuojj",
    benjamin = {};
benjamin.name = name;
delete benjamin.name;
//Outputs: "zuojj"
console.log(name);

这里，name和benjamin.name映射到相同的值，真如你所看到的，删除benjamin.name并不会影响name.

Das obige ist der detaillierte Inhalt vonWas sind Lösch- und Löschoperatoren in js? Und Anwendungsbeispielanalyse. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!