Supprimer et supprimer les opérateurs dans les compétences javascript_javascript

Alors, pourquoi peut-on supprimer les attributs d'un objet :

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

Mais vous ne pouvez pas supprimer une variable :

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

Vous ne pouvez pas non plus supprimer une fonction :

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

Remarque : delete ne renvoie false que si une propriété ne peut pas être supprimée.

Chaque attribut a de zéro à plusieurs attributs internes - *ReadOnly, DontEnum, DontDelete et Internal**. Vous pouvez les considérer comme des balises : une propriété peut ou non avoir une propriété interne spéciale. Pour la discussion d'aujourd'hui, nous nous intéressons à DontDelete.

Lorsque les variables et les fonctions sont déclarées, elles deviennent des propriétés de l'objet Variable, soit l'objet d'activation (dans le code de fonction), soit l'objet global (dans le code global). Ces propriétés sont accompagnées de La propriété interne DontDelete est générée. Cependant, les propriétés attribuées explicitement/implicitement ne génèrent pas de DontDelete. Et c'est essentiellement pourquoi nous pouvons supprimer certaines propriétés mais pas d'autres.

var GLOBAL_OBJECT = this;

/* 'foo' est une propriété de l'objet global, qui est générée via une déclaration de variable, elle a donc la propriété interne DontDelete

C'est pourquoi il ne peut pas être supprimé*/

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

' est une propriété de l'objet global, qui est générée via une déclaration de variable, elle a donc l'enfant DontDelete

C'est pourquoi il ne peut pas non plus être supprimé*/

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

/* 'baz' est aussi une propriété de l'objet global,

Cependant, il est généré via l'affectation de propriétés, il n'y a donc pas de DontDelete

C'est pourquoi il peut être supprimé*/

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

1.5, intégrés et DontDelete | Intégrés et DontDelete

C'est pourquoi tout cela se produit : une propriété interne spéciale d'une propriété contrôle si la propriété peut ou non être supprimée. Remarque : Certaines propriétés des objets intégrés ont la propriété interne DontDelete et ne peuvent donc pas être supprimées ; les variables d'arguments spéciaux (comme nous le savons, les propriétés des objets activés) ont également la propriété length (longueur du paramètre de retour) de toute instance de fonction ; Ne pas supprimer :

(function() {
  //不能删除'arguments'，因为有DontDelete
  delete arguments; // false;
  typeof arguments; // "object"

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

Les propriétés associées aux arguments de la fonction ont également DontDelete et ne peuvent pas non plus être supprimées

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

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

1.6. Affectations de variables non déclarées | Affectations non déclarées

Vous vous souvenez peut-être qu'une affectation de variable non déclarée devient une propriété de l'objet global à moins que la propriété ne se trouve ailleurs dans la chaîne de portée. Et maintenant, nous comprenons la différence entre l'affectation de propriété et la déclaration de variable - cette dernière génère DontDelete et la première non - c'est pourquoi les affectations de variables non déclarées peuvent être supprimées.

var GLOBAL_OBJECT = this;

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

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

Remarque : les attributs internes sont déterminés lors de la génération des attributs, et les processus d'affectation ultérieurs ne modifieront pas les attributs internes des attributs existants. Il est important de comprendre cette distinction.

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

Résumé :

Les déclarations de variables et de fonctions sont des propriétés de l'objet global Activation.

Les propriétés ont des propriétés internes, dont l'une - DontDelete - est chargée de déterminer si une propriété peut être supprimée.

Les variables et déclarations de fonctions dans le code global ou le code de fonction génèrent toutes des attributs avec DontDelete.

Les paramètres de fonction sont également des attributs de l'objet d'activation et ont également DontDelete.

Supprimer les attributs dans l'objet : delete object.member

Vous ne pouvez supprimer que vos propres membres

Seules les variables globales déclarées avec var ne peuvent pas être supprimées

Les membres globaux ajoutés à l'aide de window ou window[""] peuvent être supprimés
.

ps : opérateur de suppression en Javascript

Supprimer est l'une des opérations les moins fréquemment utilisées dans le langage Javascript, mais parfois, lorsque nous devons effectuer des actions de suppression ou d'effacement, nous avons besoin de l'opération de suppression. Dans cet article, nous verrons comment l’utiliser et comment il fonctionne.

Le but de la suppression, comme vous le pensez, est de supprimer quelque chose. Plus précisément, cela supprimera les attributs de l'objet, comme dans l'exemple suivant :

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

L'opérateur

delete ne supprimera pas les variables ordinaires, comme dans l'exemple suivant :

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

Cependant, il peut supprimer les "variables globales" car ce sont en fait des propriétés de l'objet global (fenêtre dans les navigateurs).

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

L'opérateur

delete a également une valeur de retour. Si la suppression d'un attribut réussit, il renvoie true. Si l'attribut ne peut pas être supprimé car il n'est pas accessible en écriture, il renverra false ou générera une erreur s'il est présent. mode strict.

var benjamin = {
  "name": "zuojj",
  "url" : "http://www.zuojj.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_;

你可能不知道在什么情况下使用删除运算符。答案是，只要你真的想从对象中删除一个属性。

有的时候，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运算符的概述，不妥之处，欢迎大家批评指正。