Verbreiten Syntax vs Rest-Parameter in ES2015 / ES6

Ich bin verwirrt über die Verbreitung syntax und rest-parameter in ES2015. Kann jemand erklären den Unterschied zwischen Ihnen mit der richtigen Beispiele?

Man ist auf der call-Seite, der andere ist in der parameter-Liste. Oder für arrays, ist in der wörtlichen, die andere ist in einem destructuring Ausdruck.
Kann jemand erklären, warum es downvoted?
Wahrscheinlich, weil keine Forschung aufgezeigt Aufwand. Auch, wo hast du diese Begriffe, wo/wie wurden Sie so schlecht erklärt, dass Sie nicht sagen, der Unterschied?
Danke @Bergi, aber ich war in Eile.
persönliche Meinung, Ihre Kommentare bieten mehr Einblicke als die akzeptierte Antwort, die einfach unter Angabe expanding vs collapsing nicht sagen, Ihre Nutzung Fall, danke 😉

InformationsquelleAutor Nur Rony | 2015-11-24

108

Bei der Verwendung zu verbreiten, Sie bauen eine einzelne variable, die in mehr:

JS:
```
var abc = ['a', 'b', 'c'];
var def = ['d', 'e', 'f'];
var alpha = [ ...abc, ...def ];
console.log(alpha)//alpha == ['a', 'b', 'c', 'd', 'e', 'f'];
```
Bei der Verwendung von rest-Argumente, Sie brechen alle restlichen Argumente einer Funktion in einem array:

JS:
```
function sum( first, ...others ) {
    for ( var i = 0; i < others.length; i++ )
        first += others[i];
    return first;
}
console.log(sum(1,2,3,4))//sum(1, 2, 3, 4) == 10;
```
- was const [a, b, ...c] = [1, 2, 3, 4, 5, 6, 7, 8, 9]?
- dies ist rest. Lesen Sie es als a, b und der rest des Arrays.
- seine Ruhe und den Wert von c wird [3,4,5,6,7,8,9]
InformationsquelleAutor TbWill4321
57

ES6 verfügt über eine neue Funktion, drei Punkte ...

Hier ist, wie können wir diese Punkte:

Als Rest/Sammler/Sammeln
```
var [c, ...m] = [1,2,3,4,5]; //m -> [2,3,4,5]
```
Hier ...m ist ein Sammler, er sammelt die übrigen Parameter. Intern, wenn wir schreiben:

var [c, ...m] = [1,2,3,4,5];
JavaScript hat folgenden
```
var c = 1,
    m = [2, 3, 4, 5];
```
Verbreiten
```
var params = [ "hello", true, 7 ];
var other = [ 1, 2, ...params ]; //other => [1,2,"hello", true, 7]
```
Hier ...params breitet sich so assing alle seine Elemente zu other

Intern javaScript hat folgenden
```
var other = [1, 2].concat(params);
```
Hoffe, das hilft.
- Die meisten verständlich und einfachste Erklärung, die ich bisher gesehen habe.
- Sehr gut erklärt...
- Habe es... aber warum die gleiche syntax für beide???
- dies ist die beste Antwort.
- Ich Liebe Ihre Antwort. Gut erklärt.
- Das macht für mich keinen Sinn. so geben Sie ihm einen Namen mit unterschiedlichen Funktionen, je nach Kontext.
InformationsquelleAutor Manishz90
8

Zusammenfassung:

In javascript die ... überlastet ist. Es führt die verschiedenen Operationen basiert auf, wo der operator wird verwendet:
1. Wenn verwendet, in der Funktion Argumente der Funktion declaration/expression wird es konvertiert die restlichen Argumente in ein array. Diese Variante wird als die Rest Parameter syntax.
2. In anderen Fällen wird es verteilt die Werte einer iterierbar in Orten, wo keine oder mehrere Argumente (Funktionsaufrufe) oder Elemente (array-Literale) erwartet. Diese Variante wird als die Verbreiten syntax.
Beispiel:

Rest-parameter syntax:

JS:
```
function rest(first, second, ...remainder) {
  console.log(remainder);
}

//3, 4 ,5 are the remaining parameters and will be 
//merged together in to an array called remainder 
rest(1, 2, 3, 4, 5);
```
Verbreiten syntax:

JS:
```
function sum(x, y, z) {
  return x + y + z;
}

const numbers = [1, 2, 3];

//the numbers array will be spread over the 
//x y z parameters in the sum function
console.log(sum(...numbers));


//the numbers array is spread out in the array literal
//before the elements 4 and 5 are added
const newNumbers = [...numbers, 4, 5];

console.log(newNumbers);
```
InformationsquelleAutor Willem van der Veen
5

Wenn wir uns sehen "..." im code ist es entweder der Parameter oder der rest
spread-operator.

Gibt es eine einfache Möglichkeit, zwischen Ihnen zu unterscheiden:

Wenn ... ist am Ende der Funktion Parameter, dann ist das "rest-Parameter"
und sammelt den rest der Liste in das array. Wenn ... Auftritt, in einem
Funktion aufrufen oder ähnliches, es nennt sich ein "spread-operator" und baut eine
array in die Liste ein. Muster:

Rest-Parameter werden verwendet, um Funktionen, akzeptiert eine beliebige Anzahl von
Argumente. Der spread-operator wird verwendet, um die übergabe eines Arrays an Funktionen
dass erfordern in der Regel eine Liste von vielen Argumenten. Zusammen helfen Sie
Reisen Sie zwischen einer Liste und einem array von Parametern mit Leichtigkeit.
Für weitere Informationen über diese klicken Sie hier

InformationsquelleAutor jack

Im Grunde wie in Python:

>>> def func(first, *others):
...    return [first, *others]
>>> func('a', 'b', 'c')
['a', 'b', 'c']

InformationsquelleAutor Andy Mikhaylenko

3

Hinzugefügt ES6 diese drei Punkte ... hat zwei Bedeutungen, zu Verbreiten Betreiber und Rest-parameter

Spread-operator: verwenden Sie die drei Punkte zu erweitern iterables durch iterables ich meine arrays, string usw. Als Argumente. Zum Beispiel Math.max() Funktion erwarten, eine unbestimmte Anzahl von Argumenten, so dass Sie verwenden können, Spread-operator zu erweitern Elemente als Argumente auf Math.max() Funktion. Hier ein Beispiel aus mdn
```
console.log(Math.max(1, 3, 2));
//expected output: 3

console.log(Math.max(-1, -3, -2));
//expected output: -1

var array1 = [1, 3, 2];

console.log(Math.max(...array1));
//expected output: 3
```
Ein weiterer Anwendungsfall ist das hinzufügen, zum Beispiel mit diesem array
```
const videoGames = ['mario galaxy', 'zelda wind waker', 'ico'];
```
Können Sie es hinzufügen, zu einem anderen array
```
const favoritesVideoGames = ['Shadow of the colosus', ...videoGames];
```
Dann favoritesVideoGames Wert ist
```
[ 'Shadow of the colosus', 'mario galaxy', 'zelda wind waker', 'ico' ]
```
Über Rest-parameter, hier die MDN definition

Den rest-parameter-syntax erlaubt es uns, Sie zu vertreten eine unbestimmte Anzahl
Argumente als array.

Bedeutet dies, dass Sie Verpacken können viele Elemente in einem einzigen element

Hier ein Beispiel aus MDN
```
function sum(...theArgs) {
  return theArgs.reduce((previous, current) => {
    return previous + current;
  });
}

console.log(sum(1, 2, 3));
//expected output: 6

console.log(sum(1, 2, 3, 4));
//expected output: 10
```
Ich in der Regel verwirrt durch diese drei Punkte, diese Abbildung von @stephaniecodes hilft mir, mich zu erinnern Ihrer Logik. Ich erwähnen, dass ich fand seine inspiration aus dieser Abbildung um diese Frage zu beantworten.

Ich hoffe, es ist nützlich.

InformationsquelleAutor user615274
1

Javascript drei Punkten ( ... ) Betreiber kann auf zwei verschiedene Arten verwendet:
1. Rest-parameter: sammelt alle übrigen Elemente in ein array.
JS:
```
var days = ["Sat", "Sun", "Mon", "Tue", "Wed", "Thu", "Fri"];
const [sat, sun, ...weekdays] = days;
console.log(sat); //"Sat"
console.log(sun); //"Sun"
console.log(weekdays); //["Mon", "Tue", "Wed", "Thu", "Fri"]
```
1. Spread-operator: erlaubt, iterables( arrays /Objekte /strings ) erweitert werden, in einzelne Argumente/Elemente.
JS:
```
var weekdays = ["Mon", "Tue", "Wed", "Thu", "Fri"];
var days = [...weekdays, "Sat", "Sun"]; 
console.log(days) //["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
```
Beachten, dass der spread-operator können Sie das erste element, aber die rest-parameter muss der Letzte sein, der sammeln, um die restlichen Elemente .

InformationsquelleAutor Warasint

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Zusammenfassung:

Beispiel: