Was ist Array.gelten eigentlich tun

Nach der Lektüre diese Frage ALSO, ich bin immer noch ein wenig verwirrt, was Array.gelten eigentlich macht. Betrachten Sie den folgenden Codeausschnitt:

new Array(5).map(function(){
  return new Array(5);
});

Ich erwarte, dass die init ein array mit 5 undefined-Einträge, dann die Karte über Sie erstellen ein zwei-dimensionales array von 5 x 5);

Stattdessen bekomme ich nur das array, als ob es nie abgebildet über:

[undefined, undefined, undefined, undefined, undefined]

Wenn ich wickeln Sie die Konstruktor-Aufruf, um array in einem Array.gelten nennen, dann Karte über, dass es funktioniert wie erwartet:

Array.apply(null, new Array(5)).map(function(){
  return new Array(5);
});

wodurch;

[[undefined, undefined, undefined, undefined, undefined],
 [undefined, undefined, undefined, undefined, undefined],
 [undefined, undefined, undefined, undefined, undefined],
 [undefined, undefined, undefined, undefined, undefined],
 [undefined, undefined, undefined, undefined, undefined]];

Was ist der deal? Ist Array.gelten nur eine andere Art des Aufrufs new Array () oder Array.der Prototyp.Konstruktor? Gibt es irgendwelche anderen Situationen, wo dies von Vorteil wäre? Auch, warum nicht meine erste Annäherung pick-up auf der Karte war ich die Zusendung durch?

Dank!
-Neil

Erwähnenswert für jeden, der will zu umgehen, das verwirrende Array.apply(null..., was, das Sie tun können Array(5).fill(Array(5)), um ein array von fünf sparse-5-Länge arrays; oder Array(someLength).fill(someDefault).map(someFunction) auf Karte someFunction über ein array von someLength. Zum Beispiel Array(1000).fill(1).map((n,i) => n+i) gibt Sie ein array von zahlen von 1 bis 1000

InformationsquelleAutor Neil | 2014-08-26

53

Gute Frage!

Den Array Konstruktor-Funktion (mit benutzt werden kann, ohne new), wenn vergangen, mehr als 1 argument, erstellt ein array mit den übergebenen Argumenten als Elemente. Damit Sie dies tun können:
```
Array(1, 2, 3); //=> [1, 2, 3]
```
Wie Sie wahrscheinlich wissen, Function.prototype.apply können Sie Argumente angeben, um eine Funktion in form eines array. So ruft Array.apply (was erbt seine .apply() - Methode von Funktions-Prototyp; jede Funktion, die eine Instanz-Funktion ermöglicht es Ihnen, dies zu tun), die Funktionalität äquivalent zu dem code oben:
```
Array.apply(null, [1, 2, 3]); //=> [1, 2, 3]
```
Nun, hier ist, warum die Dinge sind ein wenig verwirrend. Die Array.prototype.map Methode ist spec ' D in einer solchen Weise, dass es sich mit sparse arrays speziell. Ein sparse-array ist eine, die hat eine "Länge" ist größer als die Anzahl der Elemente, die tatsächlich eingesetzt wurde. Zum Beispiel:
```
var arr = [];
arr[0] = 'foo';
arr[5] = 'bar';
```
Array gebaut wurden haben eine length Eigenschaft von 6, weil es ein element mit dem index 0 und eine bei index 5. Jedoch, da keine Elemente immer eingesetzt zwischen diesen Indizes, wenn Sie anrufen map auf Sie, Sie werden sehen, dass die mapping-Funktion wird nicht angewendet, um die fehlenden Elemente:
```
//This should throw, right? Since elements 1 through 4 are undefined?
var lengths = arr.map(function(s) { return s.length; });

//Nope!
lengths; //=> [3, , , , , 3]
```
Und warum sehen wir dieses Verhalten in deinem Beispiel mit new Array(5)? Sie Ahnen es: weil die array-Konstruktor, wenn da ein einziges argument, schafft eine spärlich array mit der angegebenen Länge.

Also das Problem hier ist, dass, während map (und andere Methoden auf Array.prototype wie forEach) verhält sich speziell mit Bezug auf sparse-arrays durch das überspringen über die fehlenden Werte, die Function.prototype.apply Methode keinen solchen besonderen Verhalten.
- Also, in einem Fall der Indizes waren nicht definiert, und im anderen, der die Indizes definiert wurden als nicht definiert?
- Es macht mich beinahe traurig, es zu sagen, aber... ja. Dies ist der gleiche Grund, warum arr[1] = undefined; ist nicht Funktionalität entspricht delete arr[1];
- Danke für die Erklärung. Wenn ich bin, verstehen Sie richtig, Sie sagen, dass, wenn ich Array.gelten, ich bin eigentlich mit der Funktion.Prototyp statt des Arrays.Prototyp?
- Ja. Array.anwenden verwendet wird, da beide anzeigen und anwenden sind so definiert, dass Array aber nur gelten, definiert ist, für die Funktion.
- Ich schlage vor, diese Wahl als die Antwort
InformationsquelleAutor Dan Tao
0

Es ist sehr interessante Beispiel. Und ziemlich gute Antwort von Dan Tao. Aber ich denke, dass kann ich Ihnen ein wenig zusätzliche Erklärung.

Im ersten Fall

new Array(5)

erzeugt ein leeres Objekt, dann geht es um throw-Funktion und gived Länge von 5. Da fehlen alle anderen Argumente für dieses Objekt wird keine zugeordneten Einträge.
```
//Array(5) [ <5 empty slots> ]
```
Und wenn Sie versuchen, auf "anzeigen" werden diese Einträge nichts wirklich passiert ist, weil der fehlende real-Einträge.

Jedoch, wenn Sie versuchen, nach diesem Schritt "array[0]" zum Beispiel, es gibt "undefined"...

In den nächsten Fall verwenden Sie "Call" - Methode der Array () - Funktion nach dem ersten "new Array(5)" (aber im Moment hat es keine differense "Call" oder "Bauen" - Modus, um die Verwendung mit Array()).

Array.apply(null, new Array(5))

So", new Array(5)" bereits gived als Ergebnis-Array(5) [ <5 leere slots> ] und " - Funktion.der Prototyp.apply()" setzt in diesem array werden die fünf Parameter, die Array () - Funktion bekommt. Und im aktuellen Schritt erhalten wir:
```
//Array(5) [ undefined, undefined, undefined, undefined, undefined ]
```
Diese sind fünf echte Einträge. Und was wir tun können "map()" mit Ihnen. Aber es ist ein litle Fehler in Ihrem Ergebnis, denn wir erhalten derzeit nach

Array.apply(null, new Array(5)).map(function() { return new Array(5);
});

etwas anderes Ergebnis
```
/*
[…]    
0: Array(5) [ <5 empty slots> ]    
1: Array(5) [ <5 empty slots> ]    
2: Array(5) [ <5 empty slots> ]     
3: Array(5) [ <5 empty slots> ]     
4: Array(5) [ <5 empty slots> ]
*/
```
und präzise, um "fünf auf fünf, "undefined" Ergebnis, das wir brauchen, zu wenig aktualisieren Sie Ihren code
```
Array.apply(null, new Array(5)).map(function(){ return Array.apply(null,new Array(5)); });
```
diese wird wieder "fünf auf fünf, "undefined" - array.
```
/*
[…] 
0: Array(5) [ undefined, undefined, undefined, … ] 
1: Array(5) [ undefined, undefined, undefined, … ] 
2: Array(5) [ undefined, undefined, undefined, … ] 
3: Array(5) [ undefined, undefined, undefined, … ] 
4: Array(5) [ undefined, undefined, undefined, … ]
*/
```
Aber was Rede ich, ist, dass nicht nur "apply ()" - Funktion aktuelle Verhalten zu zerlegen array, ohne Einträge. Ich gebe Ihnen ein Beispiel:
```
Array(...new Array(5)).map(() => Array(...new Array(5)));
```
dieser wird tatsächlich gived uns genau das gleiche Ergebnis - fünf auf fünf undefiniert.

Wenn wir einen genaueren Blick, im ersten Fall (new Array(5)) "Array ()" - Funktion erhalten, ist ein leeres Objekt läuft es denn im "Bauen" - Modus, und hat einen parameter (5), aber in der zweiten Aktion

Array.apply() || Array(...)

es tatsächlich bekommt mehrere Parameter, die kommt aus dem array zerlegt.

Es ist, weil der "apply()" oder "..." das Verhalten der ZERLEGUNG des arrays. Wenn sieht es die Länge der bestimmten array-it-auto zu verwandeln "leeren slots" in Undefinierte Werte, egal "apply()" oder spread-operator gibt es.

Referense von Ecma-262/6.0

(http://www.ecma-international.org/ecma-262/6.0/#sec-function.prototype.apply)
```
19.2.3.1 Function.prototype.apply
    1. If IsCallable(func) is false, throw a TypeError exception.
    2. If argArray is null or undefined, then Return Call(func, thisArg).
    3. Let argList be CreateListFromArrayLike(argArray).

    7.3.17 CreateListFromArrayLike (obj [, elementTypes] )     
        1. ReturnIfAbrupt(obj).
        2. If elementTypes was not passed, let elementTypes be (Undefined, Null, Boolean, String, Symbol, Number, Object).
        3. If Type(obj) is not Object, throw a TypeError exception.
        4. Let len be ToLength(Get(obj, "length")).
        5. ReturnIfAbrupt(len).
        6. Let list be an empty List.
        7. Let index be 0.
        8. Repeat while index < len
            a. Let indexName be ToString(index).
            b. Let next be Get(obj, indexName).
            c. ReturnIfAbrupt(next).
            d. If Type(next) is not an element of elementTypes, throw a TypeError exception.
            e. Append next as the last element of list.
            f. Set index to index + 1.
        9. Return list.
```
Hier in '8a' - Klausel, erhalten wir "0", "1"... indexNames, Sie zu übergeben in '8b' zu arraylike argument - array["0"], array["1"]... und wenn jedes element angefordert wird, es gibt "undefined" Wert, wenn wir versuchen, Werte von zurückgegebenen array von "new Array(5)", die übergeben wird, gelten die () - Funktion. So "CreateListFromArrayLike" beendet mit fünf Argumenten nicht und gelten Sie als Parameter ein Array () - Funktion.

Spread-operator verwendet iteration protokol statt, aber in der Praxis handeln Sie simulary in diesem Fall.

InformationsquelleAutor AndreyGS

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.