Lösch- und Löschoperatoren in javascript_javascript-Fähigkeiten

Warum können wir also die Attribute eines Objekts löschen:

var x = { a: 1 };
delete x.a; // true
x.a; // undefined

Aber Sie können eine Variable nicht löschen:

var x = 1;
delete x; // false;
x; // 1

Sie können eine Funktion auch nicht löschen:

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

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;

/* '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

' 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"

/* '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"

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

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

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

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"

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);

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);

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);

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;

虽然这有效地切断从原来的值的属性，但该属性本身仍然存在的对象上，你可以看到如下：

// Outputs: Object { name: null, url: "http://www.zuojj.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.

以上，就是我对delete运算符的概述，不妥之处，欢迎大家批评指正。