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"
}) ();

(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.

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"

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

< Der 🎜>Delete-Operator löscht keine normalen Variablen, wie im folgenden Beispiel:

var Benjamin = {
  "name": "zuojj",
  "url" : "//m.sbmmt.com"
};
delete Benjamin.name;
//Outputs: Object { url: "//m.sbmmt.com" }
console.log(Benjamin);

var benjamin = "//m.sbmmt.com";
delete benjamin;
//Outputs: "//m.sbmmt.com"
console.log(benjamin);

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" : "//m.sbmmt.com"
};
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: "//m.sbmmt.com" }
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!