【JavaScript】Durchquerung von Objekten

Aufzählbarkeit von Eigenschaften

• Aufzählbare Eigenschaften sind solche, deren internes „aufzählbares“ Flag auf true gesetzt ist
  • Object.getOwnPropertyDescriptorStatische Methoden geben ein Objekt zurück, das die Konfiguration einer bestimmten Eigenschaft für das angegebene Objekt beschreibt.
• Für Eigenschaften, die durch direkte Zuweisung und Eigenschaft initialisiert werden, wird standardmäßig der Identitätswert verwendettrue

let obj = {
    
    
    name: "小明",
    age: 22
}
console.log(Object.getOwnPropertyDescriptor(obj, "name"));

• Für Attribute, die über Object.defineProperty usw. definiert wurden, ist dieser ID-Wert standardmäßig false
  • Object.defineProperty()Statische Methoden definieren direkt eine neue Eigenschaft eines Objekts oder ändern dessen vorhandene Eigenschaften.

const obj = {
    
    }
Object.defineProperty(obj, "name", {
    
    
    value: "小明",
});
console.log(Object.getOwnPropertyDescriptor(obj, "name"));

für...von

for...ofEs kann auch durchlaufen werden, jedoch nur iterierbare Objekte, keine gewöhnlichen Objekte.

Wie kann man also feststellen, ob es sich um ein iterierbares Objekt handelt?

• UmIterable zu implementieren, muss ein Objekt@@iteratorSymbol.iterator< implementieren a i =4>-Methode, was bedeutet, dass dieses Objekt (oder jedes Objekt in seiner Prototypenkette) eine Eigenschaft mit dem Schlüsselwert haben muss.

  let arr = [10, 20, 30] 
  let obj = {
        
        a:1,b:2}
  let str = "hello"
  let map1 = new Map([["k1","v1"], ["k2", "v2"]])
  console.log(arr[Symbol.iterator]) //ƒ values() { [native code] }
  console.log(obj[Symbol.iterator]) //undefined
  console.log(str[Symbol.iterator]) //undefined
  console.log(map1[Symbol.iterator]) //undefined
  

  ohne Array , Object, String, Map außen, mit a>. , set, ArgumentsDOM集合

Obwohl das Attribut Symbol.iterator bei gewöhnlichen Objekten nicht vorhanden ist, können wir es per Handschrift implementieren.

let Alice = {
    
    
    heigh: 168,
    age: 19,
    hobby: ['sing', 'dance', 'speak'],
    todo:function(){
    
    
        console.log('dududu...');
    },
    [Symbol.iterator](){
    
    
        const this_ = this
        const key_value = Object.entries(this_)
        let index = 0

        return {
    
    
            next(){
    
                
                if(index < key_value.length){
    
    
                    const ret = {
    
    
                        value: key_value[index][1],
                        done: false}
                    index++
                    return ret
                }else{
    
    
                    return {
    
    value: undefined, done: true}
                }
            }
        }
    }
}

for(let val of classes){
    
    
    console.log(val);
}

Objektdurchquerung

für in

• Durchlaufen Sie die aufzählbaren Eigenschaften des Objekts mit Ausnahme des Symbols, einschließlich geerbter aufzählbarer Eigenschaften.

let Alice = {
    
    
    height: "170", 
    hobby: ['dance','sing','drawing'],
    point: "cook"
}

let sym = Symbol("foo")
Alice[sym] = true

function EnglishPeople(){
    
    
    this.birthPlace = "English"
}

EnglishPeople.prototype = Alice

let obj = new EnglishPeople();

for(let prop in obj){
    
    
    console.log(`obj.${
      
      prop}=${
      
      obj[prop]}`);
}

Wenn nur die Attribute des Objekts selbst berücksichtigt werden, dann verwenden Sie hasOwnProperty() oder getOwnPropertyNames(), um zu bestimmen, ob ein Attribut ein Attribut des Objekts selbst ist.

• Object.property.hasOwnProperty(prop)Gibt einen booleschen Wert zurück, der angibt, ob das Objekt das angegebene Attribut in seinen eigenen Eigenschaften hat.

Object.getOwnPropertyNames()

• Gibt ein Array zurück, das alle eigenen Eigenschaften im angegebenen Objekt enthält (einschließlich nicht aufzählbarer Eigenschaften, aber ausgenommen Eigenschaften, die Symbolwerte als Namen verwenden).

let Alice = {
    
    
    height: "170", 
    hobby: ['dance','sing','drawing'],
    point: "cook",
}

// symbol属性
let sym = Symbol("foo")
Alice[sym] = true

// 设置不可枚举属性
Object.defineProperty(Alice, "legs", {
    
    
    value: 4
})
console.log(Object.getOwnPropertyNames(Alice));

Object.getOwnPropertySymbols()

Gibt ein Array zurück, das alle Symboleigenschaften des angegebenen Objekts enthält.

let Alice = {
    
    
    height: "170", 
    hobby: ['dance','sing','drawing'],
    point: "cook",
}

let sym = Symbol("foo")
Alice[sym] = true

const objectSymbols = Object.getOwnPropertySymbols(Alice);
console.log(objectSymbols);
console.log(objectSymbols.length);

Object.keys()

Object.keys()Durchläuft die aufzählbaren Eigenschaften des Objekts selbst und gibt ein Array zurück, das aus den aufzählbaren Zeichenfolgenschlüsseleigenschaftsnamen des angegebenen Objekts selbst besteht.

const Alice = {
    
    
    height: "170", 
    hobby: ['dance','sing','drawing'],
    point: "cook"
}
console.log(Object.keys(Alice))

• Wenn ein Nicht-Objekt-Parameter übergeben wird, wird er in ein Objekt umgewandelt. undefiend und null können nicht zur Konvertierung gezwungen werden. Darüber hinaus verfügen nur Zeichenfolgen über eigene aufzählbare Eigenschaften, während andere Typen leere Arrays zurückgeben.

// 字符串具有索引作为可枚举的自有属性
console.log(Object.keys("foo")); // ['0', '1', '2']

// 其他基本类型（除了 undefined 和 null）没有自有属性
console.log(Object.keys(100)); // []

Object.keys ist dasselbe wie die Iteration mit einer for...in-Schleife, aber die for...in-Schleife zählt auch die Eigenschaften in der Prototypenkette auf.

Es wird daher in den meisten Fällen empfohlen, Object.keys anstelle von for...in zu verwenden. Wenn Sie den Wert eines Attributs benötigen, verwenden Sie Object.values. Wenn sowohl Schlüssel als auch Werte erforderlich sind, verwenden Sie Object.entries

Object.values() | Object.entries()

Object.valuesGibt ein Array der eigenen aufzählbaren Zeichenfolgenschlüsseleigenschaftswerte des angegebenen Objekts zurück.

Object.entriesGibt ein Schlüssel-Wert-Paar zurück, das die eigene aufzählbare Zeichenfolgenschlüsseleigenschaft des angegebenen Objekts enthält.

const Alice = {
    
    
    height: "170", 
    hobby: ['dance','sing','drawing'],
    point: "cook"
}
console.log(Object.keys(Alice))
console.log(Object.values(Alice))
console.log(Object.entries(Alice))

Reflect.ownKeys()

Reflect.ownKeys(target)Gibt ein Array zurück, das aus den eigenen Eigenschaftsschlüsseln des Zielobjekts besteht

Reflect.ownKeys({
    
     z: 3, y: 2, x: 1 }); // [ "z", "y", "x" ]
Reflect.ownKeys([]); // ["length"]

Zusammenfassen:

Iterieren Sie über aufzählbare Eigenschaften:

für…in | Object.keys | Objektwerte | Objekt.Einträge | Reflect.ownKeys()

Darunter durchläuft for...in auch die aufzählbaren Eigenschaften des Prototypobjekts.

Es werden auch nicht aufzählbare Eigenschaften durchlaufen:

Object.getOwnPropertyNames

Symboltypeigenschaften für überfahrbare Objekte:

Object.getOwnPropertySymbols()