Que sont les opérateurs delete et delete en js ? Et analyse d'exemples d'utilisation

Chaque propriété a de zéro à plusieurs propriétés 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 des variables et des fonctions sont déclarées, elles deviennent des objets variables — soit des objets d'activation (dans le code de fonction) soit des objets globaux (dans le code global) — Attributs, ces attributs sont accompagnés de l'attribut interne DontDelete. 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é par déclaration de variable, il 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 par la déclaration de variable , et a donc le sous DontDelete

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

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

/* 'baz' est également une propriété d'objet globale,

Cependant, elle est générée par affectation de propriété, il n'y a donc pas de DontDelete

c'est pourquoi elle peut être supprimée* /

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

Les propriétés intégrées et DontDelete contrôlent si la propriété peut ê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 ; DontDelete :

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

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

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

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

Vous vous souvenez peut-être que les affectations de variables non déclarées deviennent des propriétés de l'objet global à moins que cette propriété ne soit trouvée 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.

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

var GLOBAL_OBJECT = this;

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

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

Résumé :

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

Les déclarations de variables et de fonctions sont des attributs 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.Members

Vous ne pouvez supprimer que vos propres membres

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

                                                                                                                                                                                                                                                           Utiliser la fenêtre L'une des opérations les moins fréquemment utilisées, mais parfois, lorsque nous devons effectuer une action de suppression ou d'effacement, une opération de suppression est nécessaire. 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 :

. < L'opérateur 🎜>delete ne supprimera pas les variables normales, comme dans l'exemple suivant :

Cependant, il peut supprimer les "variables globales" car elles sont en fait C'est une propriété de l'objet global (fenêtre dans le navigateur).

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

L'opérateur de suppression a également une valeur de retour. Si la suppression d'un attribut réussit, il renvoie vrai. Si l'attribut ne peut pas être supprimé car l'attribut est. n'est pas accessible en écriture, il retournera false ou une erreur sera générée s'il est en mode strict.

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

Vous ne savez peut-être pas quand utiliser l'opérateur de suppression. La réponse est, chaque fois que vous souhaitez vraiment supprimer une propriété d’un objet.

Parfois, le développement Javascript ne supprime pas un attribut, mais définit la valeur de l'attribut sur null, comme suit :

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

Bien que cela coupe effectivement. hors de la propriété de sa valeur d'origine, mais la propriété elle-même existe toujours sur l'objet, comme vous pouvez le voir ci-dessous :

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.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!