10. Destrukce

BY admin
|

10. Destrukce #

  • 10.1. Přehled
    • 10.1.1. Destrukce objektu
    • 10.1.2. Destrukce pole
    • 10.1.3. Kde lze destrukci použít?
  • 10.2. Pozadí: vytváření dat versus extrahování dat
  • 10.3. Vzory pro destrukci
    • 10.3.1. Vyberte si, co potřebujete
  • 10.4. Jak vzory přistupují k vnitřnostem hodnot?
    • 10.4.1. Vzory objektů nutí hodnoty k objektům
    • 10.4.2. Vzory polí pracují s iterables
  • 10.5. Výchozí hodnoty
    • 10.5.1. undefined spouští výchozí hodnoty
    • 10.5.2. Výchozí hodnoty jsou vypočteny na vyžádání
    • 10.5.3. Výchozí hodnoty mohou odkazovat na jiné proměnné ve vzoru
    • 10.5.4. Výchozí hodnoty pro vzory
    • 10.5.5. Složitější výchozí hodnoty
  • 10.6. Další funkce destrukce objektů
    • 10.6.1. Hodnota vlastnosti zkratky
    • 10.6.2. Počítačové klíče vlastností
  • 10.7. Další funkce destrukce pole
    • 10.7.1. Elision
    • 10.7.2. Operátor odpočinku (...)
  • 10.8. Můžete přiřadit více než jen proměnné
  • 10.9. Úskalí destrukce
    • 10.9.1. Nezačínejte prohlášení s kudrnatou ortézou
  • 10.10. Příklady destrukce
    • 10.10.1. Destrukce vrácených polí
    • 10.10.2. Destrukce vrácených objektů
    • 10.10.3. Array-destructuring iterable values
    • 10.10.4. Více návratových hodnot
  • 10.11. Destrukční algoritmus
    • 10.11.1. Algoritmus
    • 10.11.2. Použití algoritmu

10.1 Přehled #

Destructuring je pohodlný způsob, jak získat více hodnot z dat uložených v (případně vnořených) objekty a Pole. Může být použit v místech, která přijímají data (například na levé straně přiřazení). Jak extrahovat hodnoty, je uvedeno pomocí vzorů(přečtěte si příklady).

10.1.1 destrukce objektů #

destrukce objektů:

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'

Destructuring pomáhá při zpracování návratové hodnoty:

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

10.1.2 Pole destructuring #

Array destructuring (funguje pro všechny iterable hodnoty):

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

Destructuring pomáhá při zpracování návratové hodnoty:

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

10.1.3 Kde lze destructuring být použity? #

destrukce může být použita na následujících místech (ukazuji vzory polí, abych demonstroval; vzory objektů fungují stejně dobře):

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

můžete také destructure v for-of smyčka:

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

10.2 Pozadí: Vytváření dat oproti získávání dat #

plně pochopit, co destructuring je, pojďme nejprve zkoumat jeho širším kontextu.

JavaScript má operace pro vytváření dat, jeden majetku v době,:

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

stejnou syntaxi lze použít k extrahovat data. Znovu, jedna vlastnost najednou:

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

Navíc, tam je syntaxe postavit více vlastností zároveň, přes objekt doslovný:

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

Před ES6, tam byl žádná odpovídající mechanismus pro získávání údajů. To je to, co je destrukce-umožňuje extrahovat více vlastností z objektu pomocí vzoru objektu. Například, na levé straně přiřazení:

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

můžete také destructure Pole pomocí vzorce:

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

10.3 vzory pro destrukci #

následující dvě strany se podílejí na destrukci:

  • destruktivní zdroj: data, která mají být zničena. Například pravá strana destrukčního úkolu.
  • Destructuring target: vzor používaný pro destrukci. Například levá strana destrukčního úkolu.

destrukční cíl je buď jedním ze tří vzorů:

  • cíl úkolu. Například: x
    • cíl přiřazení je obvykle proměnná. Ale v destrukčním úkolu máte více možností, jak vysvětlím později.
  • vzor objektu. Například: { first: "pattern", last: "pattern" }
    • části vzoru objektu jsou vlastnosti, hodnoty vlastností jsou opět vzory (rekurzivně).
  • vzor pole. Například:
    • části vzoru Pole jsou prvky, prvky jsou opět vzory (rekurzivně).

to znamená, že můžete hnízdit vzory, libovolně hluboce:

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

10.3.1 Vybrat, co budete potřebovat #

Pokud jste destructure objekt, zmínit jen ty vlastnosti, které vás zajímá:

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

Pokud jste destructure Pole, můžete si vybrat pouze extrahovat prefix:

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

10.4 Jak vzorců přístup vnitřnosti hodnot? #

v zadání pattern = someValue, jak se pattern přístup co je uvnitř someValue?

10.4.1 Objekt vzory donutit hodnoty objektů #

objekt vzor donucením destructuring zdroje na objekty před přístupem vlastnosti. To znamená, že to funguje s primitivní hodnoty:

const {length : len} = 'abc'; // len = 3const {toString: s} = 123; // s = Number.prototype.toString
10.4.1.1 Nedaří objekt-destructure hodnotu #

donucování k objektu není provedena pomocí Object(), ale přes vnitřní provoz ToObject(). Obě operace zpracovávají undefined a null odlišně.

Object() převádí primitivní hodnoty wrapper objektů a listy objekty nedotčené:

> 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

v důsledku toho, můžete použít prázdný objekt vzor {} zkontrolovat, zda hodnota je coercible k objektu. Jak jsme viděli, pouze undefined a null nejsou:

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

závorky kolem výrazů jsou nezbytné, protože příkazy nesmí začínat složenými závorkami v JavaScriptu (podrobnosti jsou vysvětleny později).

10.4.2 array patterns work with iterables #

Array destructuring používá iterátor, aby se dostal k prvkům zdroje. Proto můžete Array-destructure libovolnou hodnotu, která je iterable. Podívejme se na příklady iterabilních hodnot.

řetězce jsou iterovatelné:

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

nezapomeňte, že iterátor konec řetězce, vrátí kód body („znaky Unicode“, 21 bitů), kód jednotek („JavaScript znaky“, 16 bitů). (Další informace o Unicode naleznete v kapitole “ Kapitola 24. Unicode a JavaScript “ v „mluvení JavaScript“.) Například:

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

k prvkům sady nelze přistupovat pomocí indexů, ale můžete tak učinit pomocí iterátoru. Proto, destrukce pole funguje pro sady:

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

Set iterator vždy vrací prvky v pořadí, v jakém byly vloženy, což je důvod, proč výsledek předchozího destructuring je vždy stejná.

10.4.2.1 Nedaří Pole-destructure hodnotu #

hodnota je iterable, pokud má metoda, jejíž klíč je Symbol.iterator, která vrací objekt. Array-destructuring hodí TypeError , pokud hodnota, která má být zničena, není iterable:

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

TypeError je vyvolána ještě před vstupem prvky iterable, což znamená, že můžete použít prázdné Pole vzor zkontrolovat, zda hodnota je iterable:

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

10.5 Default hodnoty #

Výchozí hodnoty jsou volitelné funkce vzory. Poskytují záložní zdroj, pokud ve zdroji není nic nalezeno. Pokud část (vlastnost objektu nebo prvek pole) nemá ve zdroji shodu, je porovnána proti:

  • jeho výchozí hodnota (pokud je zadána; je to volitelné)
  • undefined (jinak)

podívejme se na příklad. Při následující destrukci nemá prvek na indexu 0 na pravé straně žádnou shodu. Proto destrukce pokračuje porovnáním x proti 3, což vede k nastavení x na 3.

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

můžete také použít výchozí hodnoty v objektu vzory:

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

10.5.1 undefined spouští výchozí hodnoty #

Výchozí hodnoty jsou také použity v případě, že část má zápas a ten zápas je undefined:

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

zdůvodnění tohoto chování je vysvětleno v následující kapitole, v části o výchozích hodnotách parametrů.

10.5.2 výchozí hodnoty se počítají na vyžádání #

samotné výchozí hodnoty se počítají pouze v případě potřeby. Jinými slovy, tento destructuring:

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

je ekvivalentní k:

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

můžete pozorovat, že pokud budete používat 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

Nicméně, na pořadí záleží: proměnné x a y jsou deklarovány zleva doprava a produkovat ReferenceError pokud jsou přístupné před jejich prohlášení:

const  = ; // ReferenceError

10.5.4 Výchozí hodnoty pro vzory #

zatím jsme viděli jen výchozí hodnoty pro proměnné, ale můžete také spojit je s vzory:

const  = ;

Co to znamená? Vyvolejte pravidlo pro výchozí hodnoty: pokud část nemá ve zdroji shodu, destrukce pokračuje výchozí hodnotou.

prvek na indexu 0 je žádná shoda, což je důvod, proč destructuring pokračuje:

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

můžete snadno zjistit, proč věci fungují tímto způsobem, pokud jste nahradit vzor { prop: x } s variabilní pattern:

const  = ;

10.5.5 Složitější default hodnoty #

Pojďme dále prozkoumat výchozí hodnoty pro pole. V následujícím příkladu přiřadíme hodnotu x pomocí výchozí hodnoty { prop: 123 }:

const  = ;

Protože prvek Pole s indexem 0 nemá žádný zápas na pravé straně, destructuring pokračuje takto a x je nastavena na 123.

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

Nicméně, x není přiřazena hodnota tímto způsobem, pokud na pravé straně je prvek na indexu 0, protože pak výchozí hodnota není spuštěna.

const  = ;

v tomto případě destrukce pokračuje:

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

Proto, pokud chcete, x 123, pokud objekt nebo vlastnost chybí, musíte zadat výchozí hodnotu pro x sám:

const  = ;

Tady, destructuring pokračuje takto, nezávisle na tom, zda pravé straně je nebo .

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

10.6 Další objekt destructuring funkce #

10.6.1 hodnoty Nemovitosti zkrácený zápis #

hodnoty Nemovitosti zkrácený zápis jsou funkce objektu literály: Pokud je hodnota vlastnosti proměnná, která má stejný název jako klíč vlastnosti, Můžete klíč vynechat. To funguje pro destructuring taky:

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

můžete také kombinovat hodnoty nemovitosti zkrácený zápis s výchozí hodnoty:

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

10.6.2 Počítačová vlastnost klíče #

Počítačová majetku klíče jsou jiný objekt doslovný funkce, která také pracuje pro destructuring. Klíč vlastnosti můžete zadat pomocí výrazu, pokud jej umístíte do hranatých závorek:

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

Počítačová vlastnost klíče umožní destructure vlastnosti, jejichž klíče jsou symboly:

// 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 Další Pole destructuring funkce #

10.7.1 Elision #

Elision umožňuje použít syntaxi Array „díry“ přeskočit prvky během destructuring:

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

10.7.2 Zbytek obsluhy (...) #

zbytek provozovatel umožňuje extrahovat zbývající prvky iterable do Pole. Pokud je tento operátor použit uvnitř vzoru pole, musí být poslední:

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

pokud operátor nemůže najít žádné prvky, porovnává svůj operand s prázdným polem. To znamená, že nikdy neprodukuje undefined nebo null. Například:

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

operandu o zbytek provozovatel nemusí být variabilní, můžete použít vzory, příliš:

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

zbytek operátor spouští následující destructuring:

 =

10.8 můžete přiřadit více než jen proměnné #

Pokud přiřadíte přes destructuring, každý úkol, cíl může být vše, co je povoleno na levé straně normální přiřazení.

například, odkaz na ubytování (obj.prop):

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

Nebo odkaz na prvek Pole (arr):

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

můžete také přiřadit k vlastnosti objektu a prvky Pole přes zbytek operátor (...):

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

Pokud deklarujete proměnné nebo definovat parametry pomocí destructuring pak musíte použít jednoduché identifikátory, nemůžete odkazovat na vlastnosti objektu a Pole prvků.

10.9 Úskalí destructuring #

Tam jsou dvě věci, na paměti při použití destructuring:

  • nemůžete začít prohlášení s složená závorka.
  • během destrukce můžete buď deklarovat proměnné, nebo jim přiřadit, ale ne obě.

další dvě části obsahují podrobnosti.

10.9.1 nezačínejte příkaz složenou vzpěrou #

protože bloky kódu začínají složenou vzpěrou, příkazy nesmí začínat jednou. To je nešťastné, když se pomocí objektu destructuring v přiřazení:

{ a, b } = someObject; // SyntaxError

práce-kolem je postavit kompletní výraz v závorkách:

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

následující syntaxe nefunguje:

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

S let, var a const, kudrnaté rovnátka nikdy způsobit problémy:

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

10.10 příkladů destrukce #

začněme několika menšími příklady.

smyčka for-of podporuje destrukci:

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

k výměně hodnot můžete použít destrukci. To je něco, co by motory mohly optimalizovat, takže by nebylo vytvořeno žádné pole.

 = ;

můžete použít destructuring rozdělit Pole:

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

10.10.1 Destructuring vrátil Pole #

Některé vestavěné JavaScript operace vrátit Pole. Destrukce pomáhá s jejich zpracováním:

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

Pokud vás zajímá pouze ve skupinách (a ne v kompletní zápas, all), můžete použít elision přeskočit prvek pole na index 0:

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

exec() se vrací null pokud regulární výraz se neshoduje. Bohužel nemůžete zpracovat null pomocí výchozích hodnot, proto musíte v tomto případě použít operátor Or (||:

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

Array.prototype.split() vrátí pole. Proto je destrukce užitečná, pokud máte zájem o prvky, nikoli o pole:

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

10.10.2 Destructuring vrátil objekty #

Destructuring je také užitečné pro extrakci dat z objektů, které jsou vráceny pomocí funkcí, nebo metod. Například iterátorová metoda next() vrací objekt se dvěma vlastnostmi, done a value. Následující kód zaznamenává všechny prvky pole arr přes iterátor iter. Destructuring se používá v souladu.

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

10.10.3 Pole-destructuring iterable hodnoty #

Pole-destructuring pracuje s jakýmkoliv iterable hodnotu. To je občas užitečné:

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

10.10.4 Více návratové hodnoty #

vidět užitečnost více návratových hodnot, pojďme implementovat funkci findElement(a, p), který hledá první prvek v Poli a, pro které je funkce p výnosy true. Otázka zní: co by se mělo findElement() vrátit? Někdy se člověk zajímá o samotný prvek, někdy o jeho index, někdy o oba. Následující implementace vrací obojí.

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 };}

funkce iteruje přes všechny prvky array, přes Pole metoda entries(), která vrací iterable párů (linka A). Části párů jsou přístupné prostřednictvím destrukce.

Pojďme použít findElement():

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

Několik ECMAScript 6 funkce nám umožnila psát stručnější kód: zpětné šipky, funkce, návratová hodnota je destructured přes objekt vzor s vlastnost hodnota zkrácený zápis.

Díky index a element také se odkazovat na vlastnost klíče, pořadí, v jakém jsme o nich nezáleží. Můžeme je vyměnit a nic se nezmění:

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

Máme úspěšně zpracována případě nutnosti obě index a prvek. Co když nás zajímá pouze jeden z nich? Ukazuje se, že díky ECMAScript 6 se o to může postarat i naše implementace. A syntaktická režie ve srovnání s funkcemi s jedinými návratovými hodnotami je minimální.

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

pokaždé získáme pouze hodnotu jedné vlastnosti, kterou potřebujeme.

10.11 destrukční algoritmus #

tato část se zabývá destrukcí z jiného úhlu: jako rekurzivním algoritmem porovnávání vzorů.

na konci použiji algoritmus k vysvětlení rozdílu mezi následujícími dvěma deklaracemi funkcí.

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

10.11.1 algoritmus #

destructuring úkolu vypadá takto:

"pattern" = "value"

chceme použít pattern k extrahování dat z value. Nyní popíšu algoritmus, který je ve funkčním programování znám jako pattern matching (krátký: matching). Algoritmus určuje provozovatel ← („utkání“) pro destructuring úkol, který odpovídá pattern proti value a přiřadí k proměnné, zatímco dělá tak:

"pattern" ← "value"

algoritmus je uvedeno přes rekurzivní pravidla, která se od sebe oba operandy ← operátor. Deklarativní notace si může zvyknout, ale SPECIFIKACE algoritmu je stručnější. Každé pravidlo má dvě části:

  • hlava (první řádek) popisuje podmínku, která spouští pravidlo.
  • tělo (zbývající řádky) popisuje, co se stane, když je pravidlo spuštěno.

podívejme se na příklad:

  • (2c) {key: "pattern", "properties"} ← obj
     "pattern" ← obj.key {"properties"} ← obj
  • (2e) {} ← obj (žádné vlastnosti doleva)
     // Nothing to do

V článku (2c), hlavy znamená, že toto pravidlo je proveden, pokud je objekt vzor s alespoň jedním majetku a nula nebo více zbývající vlastnosti. Tento vzor je porovnán s hodnotou obj. Efekt tohoto pravidla je, že provádění pokračuje s hodnoty nemovitosti vzor být uzavřeno proti obj.key a zbývající vlastnosti jsou porovnávány proti obj.

v pravidle (2e) hlava znamená, že toto pravidlo je provedeno, pokud je vzor prázdného objektu {} porovnán s hodnotou obj. Pak se nedá nic dělat.

kdykoli je algoritmus vyvolán, pravidla se kontrolují shora dolů a provede se pouze první pravidlo, které je použitelné.

zobrazuji pouze algoritmus pro destrukční přiřazení. Deklarace destruktivních proměnných a definice destruktivních parametrů fungují podobně.

nepokrývám pokročilé funkce (počítačové klíče vlastností; zkratky hodnoty vlastností; vlastnosti objektu a prvky pole jako cíle přiřazení), buď. Pouze základy.

10.11.1.1 Vzory #

vzor je buď:

  • variabilní: x
  • objekt vzor: {"properties"}
  • Maticový vzor:

Každá z následujících částí popisuje jeden z těchto tří případů.

následující tři oddíly specifikují, jak zacházet s těmito třemi případy. Každá sekce obsahuje jedno nebo více očíslovaných pravidel.

10.11.1.2 Variabilní #
  • (1) x ← value (včetně undefined a null)
     x = value
10.11.1.3 Objekt vzor #
  • (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 (žádné vlastnosti doleva)
     // Nothing to do

10.11.1.4 Pole vzor #

Pole vzor a iterable. Algoritmus pro Pole destructuring začíná s Řadou vzoru a iterable:

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

Helper funkce:

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

prvky Pole a iterator. Algoritmus pokračuje prvky vzoru (levá strana šipky) a iterátoru, který byl získán z iterovatelné (pravá strana šipky).

  • (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 (díry, elision)
     getNext(iterator); // skip "elements" ← iterator
  • (3f) ..."pattern" ← iterator (vždy poslední část!)
     const tmp = ; for (const elem of iterator) { tmp.push(elem); } "pattern" ← tmp
  • (3g) ← iterator (žádné prvky vlevo)
     // Nothing to do

Helper funkce:

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

10.11.2 Použití algoritmu #

V ECMAScript 6, můžete simulovat pojmenované parametry, pokud volající používá objekt doslovný a volaný používá destructuring. Tato simulace je podrobně vysvětlena v kapitole o manipulaci s parametry. Následující kód ukazuje příklad: funkce move1() má dvě pojmenované parametry, x a y:

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

Existují tři výchozí hodnoty v souladu S:

  • první dvě výchozí hodnoty umožňují vynechat x a y.
  • třetí výchozí hodnota umožňuje volat move1() bez parametrů (jako v posledním řádku).

ale proč byste definovali parametry jako v předchozím úryvku kódu? Proč ne takto-což je také zcela legální kód ES6?

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

abychom zjistili, proč je move1() správný, použijeme obě funkce pro dva příklady. Než to uděláme, podívejme se, jak lze průchod parametrů vysvětlit pomocí párování.

10.11.2.1 Pozadí: předávání parametrů přes odpovídající #

Pro volání funkce, formální parametry (uvnitř definice funkce) jsou porovnávány skutečné parametry (uvnitř volání funkce). Jako příklad si vezměte následující definici funkce a následující volání funkce.

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

parametry a a b jsou nastaveny podobně jako následující destructuring.

 ←
10.11.2.2 použití move2() #

podívejme se, jak destrukce funguje pro move2().

Příklad 1. move2() vede k této destructuring:

 ←

jeden prvek Pole na levé straně nemá zápas na pravé straně, což je důvod, proč {x,y} je porovnávány výchozí hodnota a ne proti dat z pravé straně pravidla (3b, 3d):

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

Na levé straně obsahuje hodnoty nemovitosti zkrácený zápis, to je zkratka pro:

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

Tento destructuring vede k následující dva úkoly (pravidla 2c, 1):

x = 0;y = 0;

Příklad 2. Podívejme se na volání funkce move2({z:3}), které vede k následující destrukci:

 ←

na pravé straně je prvek pole v indexu 0. Proto je výchozí hodnota ignorována a dalším krokem je (pravidlo 3d):

{x, y} ← { z: 3 }

to vede k tomu, že jak x, tak y jsou nastaveny na undefined, což není to, co chceme.

10.11.2.3 použití move1() #

zkusme move1().

Příklad 1: move1()

 ←

nemáme prvek Pole s indexem 0 je na pravé straně a použít výchozí hodnotu (pravidlo 3d):

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

Na levé straně obsahuje hodnoty nemovitosti zkrácený zápis, což znamená, že tento destructuring je ekvivalentní:

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

ani vlastnost x ani vlastnost y nemají shodu na pravé straně. Proto, výchozí hodnoty jsou použity, a následující destructurings jsou prováděny další (pravidlo 2d):

x ← 0y ← 0

To vede k následující úkoly (čl. 1):

x = 0y = 0

Příklad 2: move1({z:3})

 ←

První prvek Pole vzor má zápas na pravé straně a zápas je použít, aby i nadále destructuring (článek 3d):

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

Jako v příkladu 1, nejsou tam žádné vlastnosti x a y na pravé straně a výchozí hodnoty jsou použity:

x = 0y = 0
10.11.2.4 Závěr #

příklady ukazují, že výchozí hodnoty jsou znakem vzor části (vlastnosti objektu, nebo prvky Pole). Pokud část nemá shodu nebo je porovnána s undefined, použije se výchozí hodnota. To znamená, že vzor je místo toho porovnán s výchozí hodnotou.