Was bedeutet Dekonstruktion in es6?

In es6 bezieht sich Destrukturierung auf das Extrahieren von Werten aus Arrays und Objekten nach einem bestimmten Muster und das Zuweisen von Werten zu Variablen. Zu den gängigen Methoden gehören die Objektstruktur, die Array-Destrukturierung und die gemischte Destrukturierung, bei der es sich um eine Art der Zerlegung handelt Zerlegen Sie die Datenstruktur in einen kleineren Teil des Prozesses, wodurch der Zweck der Informationsextraktion vereinfacht wird.

Die Betriebsumgebung dieses Tutorials: Windows 10-System, ECMAScript Version 6.0, Dell G3-Computer.

Was bedeutet Destrukturierung in es6?

Destrukturierung: Mit der Baidu-Enzyklopädie können Sie Werte aus Arrays und Objekten extrahieren und Variablen nach bestimmten Mustern zuweisen.

Zu den in der Entwicklung gebräuchlicheren Methoden gehören Objektdestrukturierung, Array-Destrukturierung und gemischte Destrukturierung. Hierbei handelt es sich um einen Prozess, bei dem eine Datenstruktur in kleinere Teile zerlegt wird, um die Extraktion von Informationen zu vereinfachen.

Objektdestrukturierung

Traditionelle Methode, um den Wert im Objekt zu erhalten

let node = {
    type: 'Identifier',
    name: 'foo'
}
console.log(node.type) // Identifier
console.log(node.foo) // foo

Destrukturierung verwenden

let node = {
    type: 'Identifier',
    name: 'foo'
}
let { type, name } = node
console.log(type) // Identifier
console.log(name) // foo

Wenn der angegebene lokale Variablenname im Objekt nicht vorhanden ist, wird der lokalen Variablen der Wert undefiniert zugewiesen

let { type, name, value } = node
console.log(type) // Identifier
console.log(name) // foo
console.log(value) // undefined

Wenn das angegebene Attribut nicht vorhanden ist, können Sie einen beliebigen Standardwert für das nicht vorhandene Attribut definieren.

let { type, name, value = true } = node
console.log(type) // Identifier
console.log(name) // foo
console.log(value) // true

Geben Sie einen neuen Variablennamen für die Destrukturierung und Zuweisung an.

let arr = {
  six: '男',
  age: 19
}
let {six:newSix, age:newAge} = arr
console.log(six, age) // six is not defined
console.log(newSix, newAge) // 男 19

Finden Sie, dass das oben Gesagte seltsam ist? Objektzuweisungen haben links vier Attribute und rechts sind vier Attribute der Wert. Bei der Destrukturierung ist die rechte Seite jedoch das Attribut und die linke Seite der Wert, sodass sich der neue Variablenname auf der rechten Seite befindet.

Wenn Sie let, var oder const verwenden, um ein Objekt zu zerstören, darf der Wert des zerstörten Objekts nicht vorhanden sein.

Wenn var-, let- und const-Zuweisungen nicht verwendet werden, muss die Destrukturierungsanweisung mit () umschlossen werden.

({type, name} = node);//{} wird als Codeblock in js verwendet Nur das Gleichheitszeichen wird gemeldet.

Destrukturierung verschachtelter Objekte

Bei der Destrukturierung eines verschachtelten Objekts verwenden wir weiterhin geschweifte Klammern in der ersten Ebene der Destrukturierung, um einen Drilldown zur nächsten Ebene durchzuführen, um einen Blick darauf zu werfen Zuerst eine Kastanie:

let node = {
    type: "Identifier",
    name: "foo",
    loc: {
        start: {
            line: 1,
            column: 1
        },
        end: {
            line: 1,
            column: 4
        }
    }
}

Oben Es handelt sich um einen verschachtelten Objektknoten. Lassen Sie uns zuerst die erste Ebene dekonstruieren. Sie können sehen, dass wir die Reihenfolge der Attribute in {} absichtlich gestört haben und das Ergebnis immer noch korrekt ausgegeben wird Wir können davon ausgehen, dass die entsprechende Methode unabhängig von der Reihenfolge auf dem Namen basieren sollte.

Dekonstruieren Sie die zweite Ebene weiter

let { loc, type, name } = node // {} Identifier foo

Hier können wir auch start einer neuen benutzerdefinierten lokalen Variablen zuweisen. Angenommen, wir weisen sie newStart zu.

let { loc: { start }} = node;
console.log(start.line); // 1
console.log(start.column); // 4

Die Zusammenfassung lautet wie folgt:

Alle Bezeichner vor Doppelpunkten repräsentieren die Abrufposition in das Objekt, dessen rechte Seite der zuzuweisende Variablenname ist; wenn auf den Doppelpunkt geschweifte Klammern folgen, bedeutet dies, dass der endgültige zuzuweisende Wert auf einer tieferen Ebene innerhalb des Objekts verschachtelt ist.

Array-Destrukturierung

Array-Destrukturierung verwendet Array-Literale, und alle Destrukturierungsvorgänge werden innerhalb des Arrays abgeschlossen, und bei der Array-Destrukturierung müssen nicht die benannten Eigenschaften des Objekts wie die Syntax von Objektliteralen verwendet werden.

let { loc: { start: newStart }} = node
console.log(newStart.line) // 1
console.log(newStart.column) // 4

In der Array-Destrukturierungssyntax wählen wir den Wert hauptsächlich anhand seiner Position im Array aus und können in jeder Variablen gespeichert werden. Elemente, die nicht explizit deklariert werden, werden direkt ignoriert.

let colors = [ 'red', 'green', 'blue' ]
let [ firstColor, secondColor ] = colors
console.log(firstColor) // 'red'
console.log(secondColor) // 'green'

Variablenaustausch bei der Array-Destrukturierung

Im herkömmlichen ES5 erfordert der Austausch von Werten im Allgemeinen die Einführung einer dritten temporären Variablen als Übertragung. Wenn Sie jedoch die Zuweisungssyntax für die Array-Destrukturierung verwenden, müssen keine zusätzlichen Variablen hinzugefügt werden.

let [ , , thirdColor ] = colors
console.log(thirdColor) // 'blue'

Verschachtelte Datendestrukturierung

// ES5中互换值：
 let a = 1, b = 2, tmp;
 tmp = a
 a = b
 b = tmp
 console.log(a, b) // 2, 1
 // ES6中互换值
 let a = 1, b = 2;
 [ a, b ] = [b, a]
 console.log(a, b) // 2, 1

Standardwert

Sie können auch einen Standardwert für jede Position im Array im Array-Destrukturierungszuweisungsausdruck hinzufügen, wenn das Attribut an der angegebenen Position nicht vorhanden ist oder sein Wert undefiniert ist Es wird der Standardwert verwendet

 let colors = [ 'red', [ 'green', 'lightgreen'], 'blue' ]
 let [ firstColor, [ secondColor, thirdColor ], fourthColor ] = colors
 console.log(firstColor) // red
console.log(secondColor) // green
console.log(thirdColor) // lightgreen
console.log(fourthColor) // blue

Unbestimmtes Element

...Wir alle sollten seinen Zweck als Erweiterungsoperator kennen. Er kann verwendet werden, um das Array beim Betrieb eines Arrays zu einer Zeichenfolge zu erweitern. Bei der Array-Destrukturierung können die verbleibenden Elemente im Array mithilfe der ...-Syntax einer bestimmten Variablen zugewiesen werden.

let colors = [ 'red' ]
let [ firstColor, secondColor = 'green' ] = colors
console.log(firstColor) // red
console.log(secondColor) // green

Array-Kopie

In ES5 verwenden Entwickler häufig die concat()-Methode, um Arrays zu klonen.

let colors = [ 'red', 'green', 'blue' ]
let [ firstColor, ...restColors ] = colors
console.log(firstColosr) // 'red'
console.log(restColors.length); // 2
console.log(restColors[0]); // "green"
console.log(restColors[1]); // "blue"

Die concat()-Methode ist ursprünglich dafür konzipiert, zwei Arrays zu verbinden, wenn beim Aufruf keine Parameter übergeben werden zurückgegeben. Eine Kopie von

In ES6 kann das gleiche Ziel durch die Syntax unbestimmter Elemente erreicht werden

var colors = [ "red", "green", "blue" ];
var clonedColors = colors.concat();
console.log(clonedColors); //"[red,green,blue]"

Im destrukturierten Array muss das unbestimmte Element der letzte Eintrag sein, und das Hinzufügen von Kommas danach führt zum Auslösen des Programms ein Syntaxfehler.

Gemischte Dekonstruktion

let colors = [ "red", "green", "blue" ];
let [ ...clonedColors ] = colors;
console.log(clonedColors); //"[red,green,blue]"

Im obigen Code enthält das Fehlerobjekt Fehler, Fehler sind ein Array und enthalten neue Objekte, und die Nachricht im Objekt wird extrahiert. Wir können die obige Kastanie Schritt für Schritt zerlegen und dekonstruieren:

let err = {
    errors: [
        {
            msg: 'this is a message'
        },
        {
            title: 'this is a title'
        }
    ]
}

Schauen wir uns eine kompliziertere an. Solange Sie die Reihenfolge finden, ist dies tatsächlich immer noch sehr einfach zu verstehen.

let { errors } = err
let [ firstArr ] = errors
let { msg } = firstArr
console.log(msg) // 'this is a message'
也可以这样解构
let [ , { title }] = err.errors
console.log(title) // 'this is a title'
let [{ msg }] = err.errors
console.log(msg) // 'this is a message'

Tatsächliche Verwendung – Parameterdestrukturierung

wird im Allgemeinen beim Kapseln von Funktionsparametern verwendet, wie unten gezeigt:

let node = {
    type: "Identifier",
    loc: {
      start: {
      line: 1,
      column: 1
       }
    },
    range: [0, 3]
};
let {
    loc: { start },
    range: [ startIndex ]
  } = node;
console.log(start.line); // 1
console.log(start.column); // 1
console.log(startIndex); // 0

[Verwandte Empfehlungen:

Javascript-Video-Tutorial

, Web-Frontend]

Das obige ist der detaillierte Inhalt vonWas bedeutet Dekonstruktion in es6?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!