Resumen

La asignación por desestructuración es una extensión del operador de asignación.

Es un método de coincidencia de patrones para arrays u objetos, que luego asigna valores a las variables contenidas en ellos.

Es conciso y legible al escribir código, con una semántica más clara y comprensible; también facilita la obtención de campos de datos en objetos complejos.


Modelo de desestructuración

En la desestructuración participan las siguientes dos partes:

    La fuente de la desestructuración: la parte derecha de la expresión de asignación por desestructuración.
  • El objetivo de la desestructuración: la parte izquierda de la expresión de asignación por desestructuración.

Desestructuración del modelo de array (Array)

Básico

let [a, b, c] = [1, 2, 3]; // a = 1 // b = 2 // c = 3

Anidable

let [a, [[b], c]] = [1, [[2], 3]]; // a = 1 // b = 2 // c = 3

Ignorable

let [a, , b] = [1, 2, 3]; // a = 1 // b = 3

Desestructuración incompleta

let [a = 1, b] = []; // a = 1, b = undefined

Operador de resto

let [a, ...b] = [1, 2, 3]; //a = 1 //b = [2, 3]

Cadenas, etc.

En la desestructuración de arrays, si el objetivo de la desestructuración es un objeto iterable, se puede realizar la asignación por desestructuración. Un objeto iterable es aquel que implementa la interfaz Iterator.

let [a, b, c, d, e] = 'hello'; // a = 'h' // b = 'e' // c = 'l' // d = 'l' // e = 'o'

Valores por defecto en la desestructuración

let [a = 2] = [undefined]; // a = 2

Cuando el patrón de desestructuración tiene un resultado de coincidencia y este es undefined, se activa el valor por defecto como resultado devuelto.

let [a = 3, b = a] = []; // a = 3, b = 3 let [a = 3, b = a] = [1]; // a = 1, b = 1 let [a = 3, b = a] = [1, 2]; // a = 1, b = 2
  • El resultado de coincidencia de a y b es undefined, se activa el valor por defecto:a = 3; b = a =3
  • a se desestructura y asigna normalmente, resultado de coincidencia: a = 1; el resultado de coincidencia de b es undefined, se activa el valor por defecto:b = a =1
  • a y b se desestructuran y asignan normalmente, resultado de coincidencia:a = 1,b = 2

Desestructuración del modelo de objeto (Object)

Básico

let { foo, bar } = { foo: 'aaa', bar: 'bbb' }; // foo = 'aaa' // bar = 'bbb' let { baz : foo } = { baz : 'ddd' }; // foo = 'ddd'

Anidable e ignorable

let obj = {p: ['hello', {y: 'world'}] }; let {p: [x, { y }] } = obj; // x = 'hello' // y = 'world' let obj = {p: ['hello', {y: 'world'}] }; let {p: [x, { }] } = obj; // x = 'hello'

Desestructuración incompleta

let obj = {p: [{y: 'world'}] }; let {p: [{ y }, x ] } = obj; // x = undefined // y = 'world'

Operador de resto

let {a, b, ...rest} = {a: 10, b: 20, c: 30, d: 40}; // a = 10 // b = 20 // rest = {c: 30, d: 40}

Valores por defecto en la desestructuración

let {a = 10, b = 5} = {a: 3}; // a = 3; b = 5; let {a: aa = 10, b: bb = 5} = {a: 3}; // aa = 3; bb = 5;