Attributs d'objet JS liés (attributs de vérification, attributs d'énumération, etc.)_compétences javascript

1. Supprimer les attributs

L'opérateur delete peut supprimer les propriétés d'un objet

Copier le code Le code est le suivant :

delete person.age //C'est-à-dire que la personne n'a plus l'attribut age
supprimer la personne['age'] //ou ceci

Supprimer déconnecte uniquement l'attribut de l'objet hôte, mais n'exploite pas les attributs dans l'attribut. Voyez qu'après la suppression de a.p, b.x est toujours 1
.

var a = {p:{x:1}};
var b = a.p;
console.log(a.p.x); //1
delete a.p;
console.log(a.p.x); //TypeError a.p is undefined
console.log(a.p); //undefined
console.log(b.x); //1

delete ne peut supprimer que ses propres propriétés, pas les propriétés héritées (pour supprimer une propriété héritée, vous devez la supprimer de l'objet prototype qui définit cette propriété. Bien sûr, cela affectera tous les objets qui héritent de ce prototype)

function inherit(p){ 
  if(p == null){  // 不能从null中继承
    throw TypeError();
  }
  if(Object.create){  //如果有这个方法就直接使用
    return Object.create(p);
  }
  var t = typeof p;
  if(t !== "object" || t !== "function"){  //要继承的对象 类型要符合
    throw TypeError();
  }
  function f(){ }; //定义一个空的构造函数
  f.prototype = p; //原型指向要继承的对象p
  return new f();  //创建f对象，此对象继承自p
}

var obj = {x:1};
var obj1 = inherit(obj);
obj1.y = 2;
console.log("x = "+obj1.x+" y = "+obj1.y); //x = 1 y = 2
delete obj1.x;
delete obj1.y;
console.log("x = "+obj1.x+" y = "+obj1.y); //x = 1 y = undefined

Bien sûr, la suppression ne peut être utilisée que pour les propriétés configurables
Par exemple

delete Object.prototype; // 不能删除 不可配置

var x = 1;
delete this.x; //不能删除
this.y = 1;
delete y; //这样可以删除

function f(){ }
delete this.f; //不能删除

2. Détecter les attributs

Utilisez "dans"

L'opérateur

in s'attend à ce que son opérande gauche soit une chaîne ou convertible en chaîne, et son opérande droit soit un objet

var data = [5,6,7];
console.log("0" in data); //有下标0
console.log(1 in data);  //1可以转换成"1"
console.log("4" in data); //下标只有 1 2 3
 
var obj = {x:1};
console.log("x" in obj); //true
console.log("y" in obj); //false
console.log("toString" in obj); //true 因为obj继承了这个方法

Utilisez hasOwnProperty() ou propertyIsEnumerable() --- ce dernier est une amélioration du premier
Pensa Gu Mingsi

var obj = {x:1};
console.log(obj.hasOwnProperty("x")); //true
console.log(obj.hasOwnProperty("y")); //false
console.log(obj.hasOwnProperty("toString")); //false 因为obj继承了这个方法,但不是它自己的

Seulement lorsqu'il est détecté qu'il s'agit d'un attribut libre et d'un attribut énumérable, ce dernier renverra vrai

var obj = {x:1};
console.log(obj.propertyIsEnumerable("x")); //true
console.log(obj.propertyIsEnumerable("y")); //false
console.log(obj.propertyIsEnumerable("toString")); //false 因为obj继承了这个方法,但不是它自己的
console.log(Object.prototype.propertyIsEnumerable("toString")); //false 因为最原始的的 toString就是不可枚举的

Bien sûr, vous pouvez également utiliser directement l'opérateur "!==" pour déterminer

var obj = {x:1};
console.log(obj.x !== undefined);//true
console.log(obj.y !== undefined);//false
console.log(obj.toString !== undefined); //true 

3. Attributs d'énumération

var obj = {x:1,y:2};
for(p in obj){
 console.log(p);//x y
 console.log(obj.p);// undefined undefined
 console.log(obj[p]);//1 2
} 

Extension 1 :

Chaque objet a son prototype, sa classe et son extensibilité associés
Pour détecter si un objet est le prototype d'un autre objet (ou s'il est dans une chaîne de prototypes), vous pouvez utiliser la méthode isPrototypeOf()

var p = {x:1}; //p原型对象继承自Object.prototype
var o = Object.create(p); //o对象继承自p

console.log(p.isPrototypeOf(o));//true
console.log(Object.prototype.isPrototypeOf(o));//true
console.log(Object.prototype.isPrototypeOf(p));//true

Bien sûr, la méthode isPrototypeOf() est très similaire à l'opérateur instanceof
L'opérateur instanceof s'attend à ce que son opérande gauche soit un objet et son opérande droit à identifier la classe de l'objet. Si l'objet de gauche est une instance de la classe de droite, l'expression renvoie vrai, sinon elle renvoie faux

var p = {x:1}; 
console.log(p instanceof Object);//true

var d = new Date();
console.log(d instanceof Date);//true
console.log(d instanceof Object);//true
console.log(d instanceof Number);//false

Extension 2 :

L'attribut de classe d'un objet est une chaîne qui représente les informations de type de l'objet

Généralement, après avoir appelé la méthode toString(), elle renvoie une forme de [classe d'objet]

Par exemple

Copier le code Le code est le suivant :

var obj = {x:1,y:2};
console.log(obj.toString());//[objet Objet]

Donc, si vous souhaitez obtenir la classe de l'objet, vous pouvez trouver le champ "class" dans la chaîne renvoyée et utiliser slice (8, -1)
Par exemple

function classOf(obj){ // 找出类名
 if(obj === null){
  return "Null";
 }
 if(obj === undefined){
  return "Undefined";
 }
 return Object.prototype.toString.call(obj).slice(8,-1);
}

console.log(classOf(1)); //Number
//注意，实际上是这些类型的变量调用toString()方法，而不是通过他们自身直接调用
//console.log(1.toString()); //会报错
var a = 1;
console.log(Number(1).toString()); //1
console.log(a.toString()); //1
console.log({x:1}.toString()); //[object Object]

console.log(classOf(1)); //Number
console.log(classOf("")); //String
console.log(classOf("str")); //String
console.log(classOf(null)); //Null
console.log(classOf(false)); //Boolean
console.log(classOf({})); //Object
console.log(classOf([])); //Array
console.log(classOf(new Date())); //Date
function f(){}
console.log(classOf(new f())); //Object