JS-Objektattribute im Zusammenhang (Prüfattribute, Aufzählungsattribute usw.)_Javascript-Kenntnisse

1. Attribute löschen

Der Löschoperator kann die Eigenschaften eines Objekts löschen

Code kopieren Der Code lautet wie folgt:

delete person.age //Das heißt, die Person hat nicht mehr das Attribut Alter
lösche Person['Alter'] //oder dieses

Löschen trennt nur das Attribut vom Hostobjekt, bearbeitet aber nicht die Attribute im Attribut. Beachten Sie, dass b.x nach dem Löschen immer noch 1 ist

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

Löschen kann nur eigene Eigenschaften löschen, keine geerbten Eigenschaften (um eine geerbte Eigenschaft zu löschen, müssen Sie sie aus dem Prototypobjekt löschen, das diese Eigenschaft definiert. Dies betrifft natürlich alle Objekte, die von diesem Prototyp erben)

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

Löschen kann natürlich nur für konfigurierbare Eigenschaften verwendet werden
Zum Beispiel

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

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

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

2. Attribute erkennen

Verwenden Sie „in“

Der

in-Operator erwartet, dass sein linker Operand ein String ist oder in einen String konvertierbar ist, und dass sein rechter Operand ein Objekt

ist

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继承了这个方法

Verwenden Sie hasOwnProperty() oder propertyIsEnumerable() --- letzteres ist eine Erweiterung des ersteren
Gu Mingsi dachte

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

Nur ​​wenn erkannt wird, dass es sich um ein freies Attribut und ein aufzählbares Attribut handelt, gibt letzteres true zurück

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就是不可枚举的

Natürlich können Sie zur Bestimmung von

auch direkt den Operator „!==" verwenden

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

3. Aufzählungsattribute

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
} 

Erweiterung 1:

Jedes Objekt hat seinen zugehörigen Prototyp, seine Klasse und seine Erweiterbarkeit
Um zu erkennen, ob ein Objekt der Prototyp eines anderen Objekts ist (oder sich in einer Prototypenkette befindet), können Sie die Methode isPrototypeOf()

verwenden

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

Natürlich ist die Methode isPrototypeOf() dem Instanzoperator sehr ähnlich
Der Instanzoperator erwartet, dass sein linker Operand ein Objekt ist und sein rechter Operand die Klasse des Objekts identifiziert. Wenn das Objekt auf der linken Seite eine Instanz der Klasse auf der rechten Seite ist, gibt der Ausdruck „true“ zurück, andernfalls gibt er „false“ zurück

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

Erweiterung 2:

Das Klassenattribut eines Objekts ist eine Zeichenfolge, die die Typinformationen des Objekts darstellt

Im Allgemeinen gibt die toString()-Methode nach dem Aufruf eine Form von [Objektklasse] zurück

Zum Beispiel

Code kopieren Der Code lautet wie folgt:

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

Wenn Sie also die Klasse des Objekts erhalten möchten, können Sie das Feld „class“ in der zurückgegebenen Zeichenfolge finden und Slice (8, -1) verwenden
Zum Beispiel

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