10. Destruição

BY admin
|

10. Destruição #

  • 10.1. Resumo
    • 10.1.1. Destruição de objectos
    • 10.1.2. Destruição de matriz
    • 10.1.3. Onde pode ser usada a destruição?
  • 10.2. Antecedentes: construção de dados versus extracção de dados
  • 10.3. Padrões de destruição
    • 10.3.1. Escolhe o que precisas.
  • 10.4. Como os padrões acessam as entranhas dos valores?
    • 10.4.1. Padrões de objetos coagem valores a objetos
    • 10.4.2. Padrões de matriz funcionam com iterables
  • 10.5. Valores por omissão
    • 10.5.1. undefined desencadeia valores predefinidos
    • 10.5.2. Os valores por defeito são calculados a pedido
    • 10.5.3. Valores padrão podem se referir a outras variáveis no padrão
    • 10.5.4. Valores predefinidos para padrões
    • 10.5.5. Valores predefinidos mais complexos
  • 10.6. Mais características de destruição de objetos
    • 10.6.1. Abreviaturas do valor da propriedade
    • 10.6.2. Chaves de propriedades computadas
  • 10.7. Mais características de destruição de Array
    • 10.7.1. Elision
    • 10.7.2. Operador de repouso (...)
  • 10.8. Você pode atribuir a mais do que apenas variáveis
  • 10.9. Armadilhas da destruição
    • 10.9.1. Não comece uma declaração com um chaveiro encaracolado
  • 10.10. Exemplos de destruição
    • 10.10.1.
    • 10.10.2. A destruição devolveu objetos
    • 10.10.3. Valores iteráveis de destruição de agregados
    • 10.10.4. Valores múltiplos de retorno
  • 10.11. O algoritmo de destruição
    • 10.11.1. The algorithm
    • 10.11.2. Aplicar o algoritmo

10.1 visão geral #

destruição é uma maneira conveniente de extrair vários valores de dados armazenados em (possivelmente aninhados) objetos e Arrays. Pode ser usado em locais que recebem dados (como o lado esquerdo de uma atribuição). Como extrair os valores é especificado através de padrões (Leia para exemplos).

10.1.1 objectos destruidores de objectos: 

const obj = { first: 'Jane', last: 'Doe' };const {first: f, last: l} = obj; // f = 'Jane'; l = 'Doe'// {prop} is short for {prop: prop}const {first, last} = obj; // first = 'Jane'; last = 'Doe'

Desestruturação ajuda com o processamento de valores de retorno:

const obj = { foo: 123 };const {writable, configurable} = Object.getOwnPropertyDescriptor(obj, 'foo');console.log(writable, configurable); // true true

10.1.2 Matriz de desestruturação #

Array desestruturantes (funciona para todos os valores iterable):

const iterable = ;const  = iterable; // x = 'a'; y = 'b'

Desestruturação ajuda com o processamento de valores de retorno:

const  = /^(\d\d\d\d)-(\d\d)-(\d\d)$/ .exec('2999-12-31');

10.1.3 Onde pode desestruturação ser usado? #

a destruição pode ser usada nos seguintes locais (estou mostrando padrões de Array para demonstrar; padrões de objetos funcionam bem):

// Variable declarations:const  = ;let  = ;var  = ;// Assignments: = ;// Parameter definitions:function f() { ··· }f();

Você também pode destructure em for-of loop:

const arr = ;for (const  of arr.entries()) { console.log(index, element);}// Output:// 0 a// 1 b

10.2 plano de Fundo: a Construção de dados versus extração de dados #

Para entender totalmente o que desestruturantes é, vamos primeiro analisar o seu contexto mais amplo.

JavaScript tem de operações para a construção de dados, uma propriedade de cada vez:

const obj = {};obj.first = 'Jane';obj.last = 'Doe';

A mesma sintaxe pode ser usada para extrair dados. Mais uma vez, uma propriedade de cada vez:

const f = obj.first;const l = obj.last;

Além disso, há a sintaxe para a construção de várias propriedades ao mesmo tempo, através de um literal de objeto:

const obj = { first: 'Jane', last: 'Doe' };

Antes de ES6, não houve a correspondente mecanismo de extração de dados. Isso é o que a destruição é-ele permite extrair várias propriedades de um objeto através de um padrão de objeto. Por exemplo, no lado esquerdo de uma atribuição:

const { first: f, last: l } = obj;

Você também pode destructure Matrizes através de padrões:

const  = ; // x = 'a'; y = 'b'

10.3 Padrões de destruição #

as duas partes seguintes estão envolvidas na destruição:

  • fonte de destruição: os dados a serem destruídos. Por exemplo, o lado direito de uma missão de destruição.
  • alvo de destruição: o padrão utilizado para a destruição. Por exemplo, o lado esquerdo de uma missão de destruição.

o alvo de destruição é um dos três padrões:

  • alvo da missão. Por exemplo: x
    • um alvo de atribuição é normalmente uma variável. Mas na missão de destruição, tens mais opções, como explicarei mais tarde.
  • padrão de objectos. Por exemplo: { first: "pattern", last: "pattern" }
    • as partes de um padrão de objeto são propriedades, os valores de propriedade são novamente padrões (recursivamente).
  • padrão de matriz. Por exemplo:
    • as partes de um padrão de Array são elementos, os elementos são novamente padrões (recursivamente).

o que significa Que você pode aninhar padrões, arbitrariamente profundamente:

const obj = { a: , b: true };const { a:  } = obj; // f = 123

10.3.1 Escolher o que você precisa #

Se você destructure um objeto, você mencionar apenas as propriedades que você está interessado em:

const { x: x } = { x: 7, y: 3 }; // x = 7

Se você destructure uma Matriz, você pode escolher para extrair somente um prefixo:

const  = ; // x='a'; y='b';

10.4 Como os padrões de acesso as entranhas de valores? #

numa missão pattern = someValue, como é que o pattern acede ao que está dentro someValue?

10.4.1 padrões de objetos coagem valores a objetos #

o padrão de objeto coage fontes de destruição a objetos antes de acessar propriedades. O que significa que ele trabalha com valores primitivos:

const {length : len} = 'abc'; // len = 3const {toString: s} = 123; // s = Number.prototype.toString
10.4.1.1 Falha ao objeto-destructure um valor #

A coerção para o objeto não é realizada através de Object(), mas através da operação interna ToObject(). As duas operações lidam com undefined e null de forma diferente.

Object() converte valores primitivos para objetos de wrapper e deixa objetos intocáveis:

> typeof Object('abc')'object'> var obj = {};> Object(obj) === objtrue

It also converts undefined and null to empty objects:

> Object(undefined){}> Object(null){}

In contrast, ToObject() throws a TypeError if it encounters undefined or null. Therefore, the following destructurings fail, even before destructuring accesses any properties:

const { prop: x } = undefined; // TypeErrorconst { prop: y } = null; // TypeError

Como conseqüência, você pode usar o objeto vazio padrão {} para verificar se um valor é coercible para um objeto. Como vimos, apenas undefined e null não são:

({} = ); // OK, Arrays are coercible to objects({} = 'abc'); // OK, strings are coercible to objects({} = undefined); // TypeError({} = null); // TypeError

os parênteses em torno das expressões são necessários porque as declarações não devem começar com Chavetas em JavaScript (detalhes são explicados mais tarde).

10.4.2 padrões de Array trabalham com iterables #

destruição de Array usa um iterador para chegar aos elementos de uma fonte. Portanto, você pode destruir qualquer valor que seja iterável. Vejamos exemplos de valores iteráveis.As cordas são iteráveis:

const  = 'abc'; // x='a'; y=

não se esqueça que o iterator sobre strings retorna pontos de código (“caracteres Unicode”, 21 bits), não Unidades de código (“caracteres JavaScript”, 16 bits). (Para mais informações sobre o Unicode, consulte o Capítulo “Capítulo 24. Unicode and JavaScript ” in “Speaking JavaScript”. Por exemplo ) :

const  = 'a\uD83D\uDCA9c'; // x='a'; y='\uD83D\uDCA9'; z='c'

Você não pode acessar os elementos de um Conjunto, através de índices, mas você pode fazê-lo através de um iterador. Portanto, a destruição de Array funciona para os conjuntos:

const  = new Set(); // x='a'; y='b';

O Set iterator retorna sempre os elementos na ordem em que foram inseridos, que é por isso que o resultado da desestruturação é sempre o mesmo.

10.4.2.1 Falhando em destruir um valor #

um valor é iterável se ele tem um método cuja chave é Symbol.iterator que retorna um objeto. A destruição de Array lança um TypeError se o valor a ser destruído não for iterável:

let x; = ; // OK, Arrays are iterable = 'abc'; // OK, strings are iterable = { * () { yield 1 } }; // OK, iterable = {}; // TypeError, empty objects are not iterable = undefined; // TypeError, not iterable = null; // TypeError, not iterable

O TypeError é lançada mesmo antes de acessar elementos da iterable, o que significa que você pode utilizar a Matriz vazia padrão para verificar se um valor é iterable:

 = {}; // TypeError, empty objects are not iterable = undefined; // TypeError, not iterable = null; // TypeError, not iterable

10.5 valores Padrão #

valores Padrão são um recurso opcional de padrões. Eles fornecem um recuo se nada for encontrado na fonte. Se uma parte (uma propriedade de objeto ou um elemento Array) não tem correspondência na fonte, ela é igualada contra:

  • o seu valor por omissão (se especificado; é opcional)
  • undefined (caso contrário,)

vejamos um exemplo. Na destruição seguinte, o elemento no index 0 não tem correspondência do lado direito. Portanto, a destruição continua combinando x com 3, o que leva a x ser ajustado para 3.

const  = ; // x = 3; y = undefined

Você também pode usar valores padrão no objeto de padrões:

const {foo: x=3, bar: y} = {}; // x = 3; y = undefined

10.5.1 undefined dispara valores padrão #

valores Padrão são usados também, se uma parte não tem um jogo e esse jogo está undefined:

const  = ; // x = 1const {prop: y=2} = {prop: undefined}; // y = 2

a razão para este comportamento é explicada no capítulo seguinte, na seção sobre valores padrão do parâmetro.

10.5.2 os valores por defeito são calculados a pedido #

os valores por defeito só são calculados quando são necessários. Em outras palavras, essa desestruturação:

const {prop: y=someFunc()} = someValue;

é equivalente a:

let y;if (someValue.prop === undefined) { y = someFunc();} else { y = someValue.prop;}

Você pode observar que, se você usar console.log():

> function log(x) { console.log(x); return 'YES' }> const = ;> a'YES'> const = ;> b123

In the second destructuring, the default value is not triggered and log() is not called.

10.5.3 Default values can refer to other variables in the pattern #

A default value can refer to any variable, including other variables in the same pattern:

const  = ; // x=3; y=3const  = ; // x=7; y=7const  = ; // x=7; y=2

no Entanto, a ordem assuntos: as variáveis x e y são declarados a partir da esquerda para a direita e produzir um ReferenceError se eles são acessados antes de suas declarações:

const  = ; // ReferenceError

10.5.4 valores Padrão para os padrões #

até agora vimos apenas os valores padrão para as variáveis, mas você também pode associá-los com os padrões de:

const  = ;

o Que isso significa? Recordar a regra para os valores padrão: se uma parte não tem correspondência na fonte, a destruição continua com o valor padrão.

O elemento de índice 0 não tem nenhuma correspondência, que é a razão da desestruturação continua com:

const { prop: x } = {}; // x = undefined

Você pode ver mais facilmente porque as coisas funcionam desta forma, se você substituir o padrão { prop: x } com a variável pattern:

const  = ;

10.5.5 Padrão mais complexo de valores #

Vamos explorar ainda mais os valores padrão para os padrões. No exemplo seguinte, atribuímos um valor a x através do valor padrão { prop: 123 }:

const  = ;

Porque o elemento de Matriz no índice 0 não tem correspondência no lado direito, desestruturação continua da seguinte forma e x está definido para 123.

const { prop: x } = { prop: 123 }; // x = 123

no Entanto, x não é atribuído um valor desse modo, se o lado direito tem um elemento no índice 0, porque, então, o valor padrão não é acionado.

const  = ;

neste caso, a destruição continua com:

const { prop: x } = {}; // x = undefined

Assim, se você quiser x para ser 123 se o objeto ou a propriedade está faltando, você precisa especificar um valor padrão para x si:

const  = ;

Aqui, a desestruturação continua, independentemente do lado direito é ou .

const { prop: x=123 } = {}; // x = 123

10.6 Mais objeto de desestruturação características #

10.6.1 valor da Propriedade shorthands #

valor da Propriedade shorthands são um recurso de literais de objeto: Se o valor da propriedade é uma variável que tem o mesmo nome que a chave da propriedade, então você pode omitir a chave. Isso funciona para desestruturantes, muito:

const { x, y } = { x: 11, y: 8 }; // x = 11; y = 8// Same as:const { x: x, y: y } = { x: 11, y: 8 };

Você também pode combinar o valor da propriedade shorthands com valores padrão:

const { x, y = 1 } = {}; // x = undefined; y = 1

10.6.2 propriedade Calculada teclas #

propriedade Calculada chaves são outro literal de objeto do recurso, que também trabalha para a desestruturação. Poderá indicar a chave de uma propriedade através de uma expressão, se a colocar entre parêntesis rectos:

const FOO = 'foo';const { : f } = { foo: 123 }; // f = 123

propriedade Calculada chaves permitem que você destructure propriedades cujas chaves são símbolos:

// Create and destructure a property whose key is a symbolconst KEY = Symbol();const obj = { : 'abc' };const { : x } = obj; // x = 'abc'// Extract Array.prototypeconst { : func } = ;console.log(typeof func); // function

10.7 Mais de Matriz desestruturação características #

10.7.1 Elision #

Elision permite que você use a sintaxe da Matriz “buracos” para pular elementos durante a desestruturação:

const  = ; // x = 'c'; y = 'd'

10.7.2 Resto do operador (...) #

O resto do operador permite que você extraia os restantes elementos de uma iterable em uma Matriz. Se este operador é usado dentro de um padrão de Array, ele deve vir por último:

const  = ; // x='a'; y=

se o operador não consegue encontrar nenhum elemento, ele corresponde ao seu operando contra a matriz vazia. Ou seja, nunca produz undefined ou null. Por exemplo:

const  = ; // x='a'; y=undefined; z=

O operando do resto do operador não tem que ser uma variável, você pode usar os padrões, muito:

const ] = ; // x = 'a'; y = 'b'; z = 'c'

O resto do operador aciona o seguinte desestruturação:

 =

10.8 Você pode atribuir a mais do que apenas variáveis #

se você atribuir via destruição, cada alvo de atribuição pode ser tudo o que é permitido no lado esquerdo de uma atribuição normal.

Por exemplo, uma referência a uma propriedade (obj.prop):

const obj = {};({ foo: obj.prop } = { foo: 123 });console.log(obj); // {prop:123}

Ou uma referência a um elemento de Matriz (arr):

const arr = ;({ bar: arr } = { bar: true });console.log(arr); //

Você também pode atribuir propriedades do objeto e elementos de Matriz via o resto do operador (...):

const obj = {}; = ; // first = 'a'; obj.prop =

Se você declarar variáveis ou definir parâmetros através de desestruturação, em seguida, você deve usar simples identificadores, você não pode se referir a propriedades do objeto e elementos da Matriz.

10.9 Armadilhas de desestruturação #

Há duas coisas a se lembrar de quando usar desestruturação:

  • Você não pode iniciar uma declaração com uma chaveta.
  • durante a destruição, você pode declarar variáveis ou atribuir a elas, mas não ambas.

as duas secções seguintes contêm os detalhes.

10.9.1 Don’t start a statement with a curly brace #

Because code blocks begin with a curly brace, statements must not begin with one. Isso é lamentável quando utilizar o objecto de desestruturação em uma atribuição:

{ a, b } = someObject; // SyntaxError

A alternativa é colocar a completa expressão entre parênteses:

({ a, b } = someObject); // OK

a sintaxe A seguir não funciona:

({ a, b }) = someObject; // SyntaxError

Com let, var e const, chavetas nunca causa problemas:

const { a, b } = someObject; // OK

10.10 exemplos de destruição #

vamos começar com alguns exemplos menores.

O for-of loop suporta desestruturação:

const map = new Map().set(false, 'no').set(true, 'yes');for (const  of map) { console.log(key + ' is ' + value);}

Você pode usar desestruturantes para trocar os valores. Isso é algo que os motores poderiam otimizar, de modo que nenhum Array seria criado.

 = ;

Você pode usar desestruturantes para dividir uma Matriz:

const  = ; // first = 'a'; rest =

10.10.1 Desestruturação devolvidos Matrizes #

Algumas construído-em JavaScript operações de retorno de Matrizes. A destruição ajuda a processá-los.:

const  = /^(\d\d\d\d)-(\d\d)-(\d\d)$/ .exec('2999-12-31');

Se você está interessado apenas em grupos (e não o encontro, all), você pode usar elision para ignorar o elemento de matriz no índice 0:

const  = /^(\d\d\d\d)-(\d\d)-(\d\d)$/ .exec('2999-12-31');

exec() retorna null se a expressão regular não corresponder. Infelizmente, você não pode lidar com null através de valores padrão, e é por isso que você deve usar o ou operador (||) neste caso:

const  = /^(\d\d\d\d)-(\d\d)-(\d\d)$/ .exec(someStr) || ;

Array.prototype.split() devolve uma matriz. Portanto, a destruição é útil se você estiver interessado nos elementos, não na matriz:

const cells = 'Jane\tDoe\tCTO'const  = cells.split('\t');console.log(firstName, lastName, title);

10.10.2 destruir objetos devolvidos #

destruir também é útil para extrair dados de objetos que são retornados por funções ou métodos. Por exemplo, o método iterador next() devolve um objecto com duas propriedades, done e value. Os seguintes códigos registram todos os elementos de Array arr através do iterador iter. Desestruturação é utilizado na linha A.

const arr = ;const iter = arr();while (true) { const {done,value} = iter.next(); // (A) if (done) break; console.log(value);}

10.10.3 Matriz-desestruturação iterable valores #

Array-desestruturação funciona com qualquer iterable valor. Isso é ocasionalmente útil.:

const  = new Set().add('a').add('b'); // x = 'a'; y = 'b'const  = 'foo'; // a = 'f'; b = 'o'

10.10.4 Vários valores de retorno #

Para ver a utilidade de vários valores de retorno, vamos implementar uma função findElement(a, p) que procura o primeiro elemento na Matriz a para que a função p retorna true. A questão é: o que deve findElement() retornar? Por vezes, interessa-se pelo próprio elemento, por vezes pelo seu índice, por vezes em ambos. A implementação seguinte retorna ambos.

function findElement(array, predicate) { for (const  of array.entries()) { // (A) if (predicate(element, index, array)) { // We found an element: return { element, index }; // Same as (property value shorthands): // { element: element, index: index } } } // We couldn't find anything; return failure values: return { element: undefined, index: -1 };}

A função itera sobre todos os elementos de array, através do método de Matriz entries(), que retorna um iterable sobre pares (linha A). As partes dos pares são acedidas através da destruição.

let’s use findElement():

const arr = ;const {element, index} = findElement(arr, x => x % 2 === 0); // element = 8, index = 1

várias características do ECMAScript 6 nos permitiram escrever um código mais conciso: o callback é uma função de seta; o valor de retorno é destruído através de um padrão de objeto com o valor de propriedade abreviaturas.

devido a index e element também se referindo a Chaves de propriedade, a ordem em que as mencionamos não importa. Podemos trocá-los e nada muda.:

const {index, element} = findElement(···);

conseguimos lidar com o caso da necessidade de índice e elemento. E se só estivermos interessados num deles? Acontece que, graças ao ECMAScript 6, a nossa implementação também pode tratar disso. E a sobrecarga sintática em comparação com funções com valores únicos de retorno é mínima.

const a = ;const {element} = findElement(a, x => x % 2 === 0); // element = 8const {index} = findElement(a, x => x % 2 === 0); // index = 1

cada vez, só extraímos o valor da única Propriedade de que precisamos.

10.11 the destructing algorithm #

This section looks at destructing from a different angle: as a recursive pattern matching algorithm.

no final, vou usar o algoritmo para explicar a diferença entre as duas declarações de funções seguintes.

function move({x=0, y=0} = {}) { ··· }function move({x, y} = { x: 0, y: 0 }) { ··· }

10.11.1 O algoritmo #

Uma desestruturação atribuição parecido com este:

"pattern" = "value"

queremos usar pattern para extrair dados a partir de value. Vou agora descrever um algoritmo para fazê-lo, que é conhecido na programação funcional como correspondência de padrões (curto: correspondência). O algoritmo especifica o operador ← (“jogo contra”) para a desestruturação da atribuição que corresponde a um pattern contra um value e atribui às variáveis, ao fazer isso,:

"pattern" ← "value"

O algoritmo é especificado através de regras recursivas que além de ter os dois operandos da ← operador. A notação declarativa pode levar algum tempo a se acostumar, mas torna a especificação do algoritmo mais concisa. Cada regra tem duas partes:

  • a cabeça (primeira linha) descreve a condição que desencadeia a regra.
  • o corpo (linhas restantes) descreve o que acontece se a regra for despoletada.

vejamos um exemplo:

  • (2c) {key: "pattern", "properties"} ← obj
     "pattern" ← obj.key {"properties"} ← obj
  • (2e) {} ← obj (sem propriedades esquerda)
     // Nothing to do

Na regra (2c), o chefe significa que esta regra é executada se houver um padrão de objeto com, pelo menos, uma propriedade e zero ou mais propriedades restantes. Esse padrão é comparado com um valor obj. O efeito desta regra é que a execução continua com o padrão de valor da propriedade sendo correspondido contra obj.key e as propriedades restantes sendo correspondidas contra obj.

In rule (2e), the head means that this rule is executed if the empty object pattern {} is matched against a value obj. Então não há nada a fazer.

sempre que o algoritmo é invocado, as regras são verificadas de cima para baixo e apenas a primeira regra aplicável é executada.

I only show the algorithm for destructuring assignment. As declarações de variáveis destrutivas e as definições de parâmetros destrutivos funcionam da mesma forma.

I don’t cover advanced features (computed property keys; property value shorthands); propriedades do objeto e elementos de array como alvos de atribuição), tanto. Só o básico.

10.11.1.1 Padrões #

Um padrão é:

  • Uma variável: x
  • Um objeto padrão: {"properties"}
  • Uma Matriz padrão:

Cada uma das seções a seguir descreve um desses três casos.

as três secções seguintes especificam como lidar com estes três casos. Cada secção contém uma ou mais regras numeradas.

10.11.1.Variável 2#
  • (1) x ← value (incluindo undefined e null)
     x = value
10.11.1.3 padrão de Objeto #
  • (2a) {"properties"} ← undefined
     throw new TypeError();
  • (2b) {"properties"} ← null
     throw new TypeError();
  • (2c) {key: "pattern", "properties"} ← obj
     "pattern" ← obj.key {"properties"} ← obj
  • (2d) {key: "pattern" = default_value, "properties"} ← obj
     const tmp = obj.key; if (tmp !== undefined) { "pattern" ← tmp } else { "pattern" ← default_value } {"properties"} ← obj
  • (2e) {} ← obj (sem propriedades esquerda)
     // Nothing to do
10.11.1.4 Matriz padrão #

Array padrão e iterable. O algoritmo para a Matriz de desestruturação começa com uma Matriz padrão e um iterable:

  • (3a) ← non_iterable
    assert(!isIterable(non_iterable))
     throw new TypeError();
  • (3b) ← iterable
    assert(isIterable(iterable))
     const iterator = iterable(); "elements" ← iterator

função Auxiliar:

function isIterable(value) { return (value !== null && typeof value === 'object' && typeof value === 'function');}

elementos de Matriz e iterador. O algoritmo continua com os elementos do padrão (lado esquerdo da seta) e o iterador que foi obtido a partir do iterável (lado direito da seta).

  • (3c) "pattern", "elements" ← iterator
     "pattern" ← getNext(iterator) // undefined after last item "elements" ← iterator
  • (3d) "pattern" = default_value, "elements" ← iterator
     const tmp = getNext(iterator); // undefined after last item if (tmp !== undefined) { "pattern" ← tmp } else { "pattern" ← default_value } "elements" ← iterator
  • (3e) , "elements" ← iterator (buraco, elision)
     getNext(iterator); // skip "elements" ← iterator
  • (3f) ..."pattern" ← iterator (sempre a última parte!)
     const tmp = ; for (const elem of iterator) { tmp.push(elem); } "pattern" ← tmp
  • (3g) ← iterator (sem elementos de esquerda)
     // Nothing to do

função Auxiliar:

function getNext(iterator) { const {done,value} = iterator.next(); return (done ? undefined : value);}

10.11.2 Aplicando o algoritmo #

Em ECMAScript 6, você pode simular parâmetros de chamada se o chamador usa um literal de objeto e o receptor utiliza desestruturação. Esta simulação é explicada em detalhe no capítulo sobre tratamento de parâmetros. O código a seguir mostra um exemplo: function move1() tem dois parâmetros, o nome x e y:

function move1({x=0, y=0} = {}) { // (A) return ;}move1({x: 3, y: 8}); // move1({x: 3}); // move1({}); // move1(); //

Existem três valores padrão na linha de Um:

  • Os dois primeiros valores padrão permite que você omitir x e y.
  • o terceiro valor padrão permite chamar move1() sem parâmetros (como na última linha).

mas por que você definiria os parâmetros como no excerto de código anterior? Por que não o seguinte – que é também um código ES6 totalmente legal?

function move2({x, y} = { x: 0, y: 0 }) { return ;}

para ver por que move1() está correto, vamos usar ambas as funções para dois exemplos. Antes de fazermos isso, vamos ver como a passagem de Parâmetros pode ser explicada através da correspondência.

10.11.2.1 fundo: passando parâmetros através da correspondência #

para chamadas de funções, os parâmetros formais (definições de funções internas) são comparados com parâmetros reais (chamadas de funções internas). Como exemplo, tome a seguinte definição de função e a seguinte chamada de função.

function func(a=0, b=0) { ··· }func(1, 2);

Os parâmetros a e b são definidos de forma semelhante ao seguinte desestruturação.

 ←
10.11.2.2 Usando move2() #

Vamos examinar como a desestruturação funciona para move2().Exemplo 1. move2() leva à desestruturação:

 ←

O único elemento de Matriz do lado esquerdo não tem uma correspondência no lado direito, que é a razão {x,y} é comparado com o valor padrão, e não contra, os dados do lado direito (regras 3b, 3d):

{x, y} ← { x: 0, y: 0 }

O lado esquerdo contém o valor da propriedade shorthands, é uma abreviatura para:

{x: x, y: y} ← { x: 0, y: 0 }

Esta desestruturação leva para os dois seguintes atribuições (regras 2c, 1):

x = 0;y = 0;

Exemplo 2. Vamos examinar a chamada de função move2({z:3}) que leva à seguinte destruição:

 ←

há um elemento Array no índice 0 do lado direito. Portanto, o valor padrão é ignorado e o próximo passo é (Regra 3d):

{x, y} ← { z: 3 }

isso leva a que tanto x e y sejam definidos para undefined, o que não é o que queremos.

10. 11. 2. 3 utilização move1() #

vamos tentar move1().

Exemplo 1: move1()

 ←

não temos um elemento de Matriz no índice 0 sobre o lado direito e use o valor padrão (regra 3d):

{x=0, y=0} ← {}

O lado esquerdo contém o valor da propriedade shorthands, o que significa que esta desestruturação é equivalente a:

{x: x=0, y: y=0} ← {}

Nem a propriedade x nem propriedade y tem uma correspondência no lado direito. Portanto, os valores padrão são usados e o seguinte destructurings são realizadas seguinte (regra 2d):

x ← 0y ← 0

Que faz com que as seguintes atribuições (regra 1):

x = 0y = 0

Exemplo 2: move1({z:3})

 ←

O primeiro elemento da Matriz padrão tem uma correspondência no lado direito e que correspondam é usado para continuar a desestruturação (regra 3d):

{x=0, y=0} ← {z:3}

Como no exemplo 1, não existem propriedades x e y no lado direito e os valores padrão são usados:

x = 0y = 0
10.11.2.4 Conclusão #

Os exemplos demonstram que os valores padrão são um recurso de padrão de componentes (propriedades do objeto ou elementos de Matriz). Se uma peça não tem correspondência ou é correspondida contra undefined então o valor padrão é usado. Ou seja, o padrão é comparado com o valor padrão, em vez disso.