Wie initialisiere ich die Länge eines Arrays in JavaScript?

542

Die meisten Tutorials, die ich über Arrays in JavaScript gelesen habe (einschließlich w3schools und devguru ), schlagen vor, dass Sie ein Array mit einer bestimmten Länge initialisieren können, indem Sie dem Array-Konstruktor mithilfe der var test = new Array(4);Syntax eine Ganzzahl übergeben .

Nachdem ich diese Syntax in meinen js-Dateien großzügig verwendet hatte, führte ich eine der Dateien über jsLint aus und es flippte aus:

Fehler: Problem in Zeile 1 Zeichen 22: Erwartet ')' und stattdessen '4' gesehen.
var test = neues Array (4);
Problem in Zeile 1, Zeichen 23: Erwartetes ';' und sah stattdessen ')'.
var test = neues Array (4);
Problem in Zeile 1, Zeichen 23: Erwartete eine Kennung und sah stattdessen ')'.

Nach dem Lesen der Erklärung des Verhaltens von jsLint sieht es so aus, als ob jsLint die new Array()Syntax nicht wirklich mag und stattdessen []beim Deklarieren von Arrays bevorzugt .

Ich habe also ein paar Fragen:

Erstens, warum? Gehe ich ein Risiko ein, wenn ich new Array()stattdessen die Syntax verwende? Gibt es Browser-Inkompatibilitäten, die ich beachten sollte?

Und zweitens, wenn ich zur Syntax in eckigen Klammern wechsle, gibt es eine Möglichkeit, ein Array zu deklarieren und seine Länge in einer Zeile festzulegen, oder muss ich so etwas tun:

var test = [];
test.length = 4;
Michael Martin-Smucker
quelle
Standard-Js raten auch von der Verwendungnew Array()im Allgemeinen ab, aber es ist in Ordnung, die Größe anzugeben. Ich denke, es kommt alles auf die Codekonsistenz im gesamten Kontext an.
Cregox
Für diejenigen, die starrere Array-Strukturen vorab zuweisen möchten , gibt es typisierte Arrays . Beachten Sie, dass die Leistungsvorteile variieren können
Rovyko

Antworten:

398
  1. Warum möchten Sie die Länge initialisieren? Theoretisch besteht hierfür keine Notwendigkeit. Dies kann sogar zu verwirrendem Verhalten führen, da alle Tests, lengthbei denen ermittelt wird, ob ein Array leer ist oder nicht, melden, dass das Array nicht leer ist.
    Einige Tests zeigen , dass die anfängliche Länge von großen Arrays Einstellung kann effizienter sein , wenn das Array danach gefüllt, aber der Performance - Gewinn (falls vorhanden) scheint von Browser zu Browser unterscheiden.

  2. jsLint gefällt nicht, new Array()weil der Konstruktor nicht eindeutig ist.

    new Array(4);

    erstellt ein leeres Array der Länge 4. Aber

    new Array('4');

    Erstellt ein Array mit dem Wert '4' .

Zu Ihrem Kommentar: In JS müssen Sie die Länge des Arrays nicht initialisieren. Es wächst dynamisch. Sie können die Länge einfach in einer Variablen speichern, z

var data = [];
var length = 5; // user defined length

for(var i = 0; i < length; i++) {
    data.push(createSomeObject());
}
Felix Kling
quelle
13
Die Anzahl der Objekte im Array ist benutzerdefiniert, daher habe ich den Benutzer eine Nummer auswählen lassen und dann das Array mit so vielen Slots initialisiert. Dann forführe ich eine Schleife aus, die über die Länge des Arrays iteriert und es füllt. Ich denke, es gibt andere Möglichkeiten, dies in JavaScript zu tun, also die eigentliche Antwort auf "Warum möchte ich das tun?" ist "Wegen alter Gewohnheiten, die sich beim Programmieren in anderen Sprachen gebildet haben." :)
Michael Martin-Smucker
4
@mlms Lassen Sie die for-Schleife einfach über die benutzerdefinierte Zahl iterieren, anstatt die Array-Länge festlegen und dann darüber iterieren zu müssen. Ist das für dich nicht sinnvoller?
Šime Vidas
151
<blockquote> Warum möchten Sie die Länge initialisieren? Theoretisch besteht hierfür keine Notwendigkeit. Und alle Tests, bei denen anhand der Länge festgestellt wird, ob ein Array leer ist oder nicht, schlagen fehl. </ Blockquote> Ähm, Leistung vielleicht? Es ist schneller, ein bereits vorhandenes Element eines Arrays festzulegen, als es im laufenden Betrieb hinzuzufügen.
Codehead
45
Der Kommentar "Zeit, alte Programmiergewohnheiten aufzugeben" ist wirklich unnötig. richtig strukturierte Sprachen werden Ecmascript Mombo Jambo immer übertreffen
user151496
10
@codehead: Antwort auf dieses Zitat: "Es ist schneller, ein bereits vorhandenes Element eines Arrays festzulegen, als es im laufenden Betrieb hinzuzufügen.": Beachten Sie, dass new Array(10)kein Array mit 10 undefinierten Elementen erstellt wird. Es wird einfach ein leeres Array mit einer Länge von 10 erstellt. Siehe diese Antwort für die böse Wahrheit: stackoverflow.com/questions/18947892/…
Milimetric
598
  • Array(5) gibt Ihnen ein Array mit der Länge 5, aber ohne Werte, daher können Sie nicht darüber iterieren.

  • Array.apply(null, Array(5)).map(function () {}) gibt Ihnen ein Array mit der Länge 5 und undefiniert als Werte, jetzt kann es wiederholt werden.

  • Array.apply(null, Array(5)).map(function (x, i) { return i; }) gibt Ihnen ein Array mit der Länge 5 und den Werten 0,1,2,3,4.

  • Array(5).forEach(alert)tut nichts, Array.apply(null, Array(5)).forEach(alert)gibt Ihnen 5 Warnungen

  • ES6gibt uns Array.fromalso jetzt kannst du auch nutzenArray.from(Array(5)).forEach(alert)

  • Wenn Sie mit einem bestimmten Wert initialisiert werden sollen, ist diese gut kennt ...
    Array.from('abcde'), Array.from('x'.repeat(5))
    oderArray.from({length: 5}, (v, i) => i) // gives [0, 1, 2, 3, 4]

Ruben Stolk
quelle
11
Das habe ich gesucht. Ich wollte eine Karte über eine logische Sequenz anwenden. das sollte es tun. Vielen Dank!
jedd.ahyoung
3
Warum gibt Array.apply () es als Wert undefiniert an?
wdanxna
5
@wdanxna Wenn Arraymehrere Argumente angegeben werden, wird das argumentsObjekt durchlaufen und jeder Wert wird explizit auf das neue Array angewendet . Wenn Sie Array.applymit einem Array oder einem Objekt mit einer Längeneigenschaft aufrufen, Arraywird die Länge verwendet, um jeden Wert des neuen Arrays explizit festzulegen. Dies ist der Grund, warum Array(5)es ein Array von 5 Elisionen Array.apply(null, Array(5))gibt , während es ein Array von 5 undefinierten gibt. Weitere Informationen finden Sie in dieser Antwort.
KylePlusPlus
2
Gibt es einen Unterschied zwischen Array (5) und neuem Array (5)?
Petr Hurtak
2
Das Array.apply(null, Array(5)) kann auch geschrieben werden als Array.apply(null, {length: 5}). Es gibt wirklich keinen großen Unterschied, aber letzteres ist eindeutig klar, dass die Absicht darin besteht, ein Array von length 5und nicht ein Array zu erstellen , das5
AlexMorley-Finch
271

Mit ES2015 können.fill() Sie jetzt einfach Folgendes tun:

// `n` is the size you want to initialize your array
// `0` is what the array will be filled with (can be any other value)
Array(n).fill(0)

Welches ist viel prägnanter als Array.apply(0, new Array(n)).map(i => value)

Es ist möglich, das 0In zu löschen .fill()und ohne Argumente auszuführen, wodurch das Array gefüllt wird undefined. ( Dies schlägt jedoch in Typescript fehl. )

AP.
quelle
1
@AralRoca Man könnte immer die Verwendung Polyfill vorgesehen, auf der MDN Seite oder prüfen , mit Modernizr .
AP.
4
Ja, bitte versuchen Sie es, bevor Sie einen Kommentar abgeben
AP.
1
@ GarretWilson und @ Christian Es ist in der Spezifikation . When Array is called as a function rather than as a constructor, it also creates and initializes a new Array object. Thus the function call Array(…) is equivalent to the object creation expression new Array(…) with the same arguments
AP.
1
@AP., Die Null ist redundant. DoArray(n).fill()
Pacerier
2
@ Pacerier Ich glaube nicht, dass die 0 redundant war. Gemäß der Typdefinition von es6 ist dies die Funktionssignatur: fill (Wert: T, start?: Number, end?: Number): this; Daher scheint der Füllwert nicht optional zu sein. Die Typoskript-Kompilierung schlägt fehl, da der Funktionsaufruf oben geschrieben wurde.
Micha Schwab
150
[...Array(6)].map(x => 0);
// [0, 0, 0, 0, 0, 0]

ODER

Array(6).fill(0);
// [0, 0, 0, 0, 0, 0]

Hinweis: Sie können keine leeren Slots schleifen, z Array(4).forEach(() => …)


ODER

( Typoskript sicher )

Array(6).fill(null).map((_, i) => i);
// [0, 1, 2, 3, 4, 5]

ODER

Klassische Methode mit einer Funktion (funktioniert in jedem Browser)

function NewArray(size) {
    var x = [];
    for (var i = 0; i < size; ++i) {
        x[i] = i;
        return x;
    }
}

var a = NewArray(10);
// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Verschachtelte Arrays erstellen

Beim Erstellen eines 2D- Arrays mit dem fillsollte intuitiv neue Instanzen erstellt werden. Was aber tatsächlich passieren wird, ist, dass dasselbe Array als Referenz gespeichert wird.

var a = Array(3).fill([6]);
// [  [6], [6], [6]  ]

a[0].push(9);
// [  [6, 9], [6, 9], [6, 9]  ]

Lösung

var a = [...Array(3)].map(x => []);

a[0].push(4, 2);
// [  [4, 2], [], []  ]

Ein 3x2-Array sieht also ungefähr so ​​aus:

[...Array(3)].map(x => Array(2).fill(0));
// [  [0, 0], [0, 0], [0, 0]  ]

N-dimensionales Array

function NArray(...dimensions) {
    var index = 0;
    function NArrayRec(dims) {
        var first = dims[0], next = dims.slice().splice(1); 
        if(dims.length > 1) 
            return Array(dims[0]).fill(null).map((x, i) => NArrayRec(next ));
        return Array(dims[0]).fill(null).map((x, i) => (index++));
    }
    return NArrayRec(dimensions);
}

var arr = NArray(3, 2, 4);
// [   [  [ 0,  1,  2,  3 ] , [  4,  5,  6,  7]  ],
//     [  [ 8,  9,  10, 11] , [ 12, 13, 14, 15]  ],
//     [  [ 16, 17, 18, 19] , [ 20, 21, 22, 23]  ]   ]

Initialisiere ein Schachbrett

var Chessboard = [...Array(8)].map((x, j) => {
    return Array(8).fill(null).map((y, i) => {
        return `${String.fromCharCode(65 + i)}${8 - j}`;
    });
});

// [ [A8, B8, C8, D8, E8, F8, G8, H8],
//   [A7, B7, C7, D7, E7, F7, G7, H7],
//   [A6, B6, C6, D6, E6, F6, G6, H6],
//   [A5, B5, C5, D5, E5, F5, G5, H5],
//   [A4, B4, C4, D4, E4, F4, G4, H4],
//   [A3, B3, C3, D3, E3, F3, G3, H3],
//   [A2, B2, C2, D2, E2, F2, G2, H2],
//   [A1, B1, C1, D1, E1, F1, G1, H1] ]
Vlad
quelle
1
a[0].push(9); // [ [6, 9], [6], [6] ] sollte sein, a[0].push(9); // [ [6, 9], [6, 9], [6, 9] ] weil jedes verschachtelte Array als Referenz gespeichert ist, so dass das Mutieren eines Arrays den Rest beeinflusst. Sie haben es vielleicht gerade falsch geschrieben, obwohl ich denke :)
Alex_Zhong
@Alex_Zhong tru, dass, danke, das in einer Bearbeitung verloren hat
Vlad
68

Der kürzeste:

[...Array(1000)]
Michael Mammoliti
quelle
10
Upvoted, aber eine Einschränkung, Sie sollten eine Zeile in JS unbedingt nicht mit a beginnen, [ohne a zu verwenden, ;da dies versucht, die obige Zeile zu dereferenzieren. Ein sicherer Weg, diese Zeile vorhersehbar in einem beliebigen Teil des Codes zu verwenden, wäre:;[...Array(1000)]//.whateverOpsNeeded()
AP.
nicht wirklich. versuchen Sie es in Entwicklertools. [...Array(5)].map((item, index) => ({ index })) Versuchen Sie dies auch:[...Array(5)]; console.log('hello');
Michael Mammoliti
2
Versuchen Sie es in einer mehrzeiligen js-Datei. Wenn Ihre erste Zeile const a = 'a'und die nächste Zeile ist [...Array(5)].//irrelevent. Was würde die erste Zeile Ihrer Meinung nach bewirken? const a = 'a'[...Array(5)]Dies würde zu Folgendem führen:Uncaught SyntaxError: Unexpected token ...
AP.
7
Das stimmt, aber in diesem Fall würde ich sagen, dass das Problem woanders liegt. Semikolons und Flusen sind heutzutage wichtig.
Michael Mammoliti
8
@AP Dieses Beispiel ist genau der Grund, warum viele Styleguides vorschreiben, jede Anweisung mit einem Semikolon zu beenden. const a = 'a'wird in diesem Fall ein Lint-Fehler sein. Jedenfalls hat es wirklich nichts mit dieser Antwort zu tun.
Graup
41

ES6 führt ein, mit Array.fromdem Sie Arrayaus beliebigen "Array-ähnlichen" oder iterierbaren Objekten ein Objekt erstellen können:

Array.from({length: 10}, (x, i) => i);
// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In diesem Fall handelt es sich {length: 10}um die minimale Definition eines "Array-ähnlichen" Objekts: ein leeres Objekt mit nur einer lengthdefinierten Eigenschaft.

Array.from Ermöglicht die Zuordnung eines zweiten Arguments zum resultierenden Array.

Alexander Shutau
quelle
2
@dain Ich denke, [... Array (10)] ist besser stackoverflow.com/a/47929322/4137472
Alexander Shutau
1
Warum besser? Von der Verwendung des Array-Konstruktors wird abgeraten, und einige Linter könnten sich auch beschweren
Cristian Traìna,
26

Dadurch wird die Eigenschaft length auf 4 initialisiert:

var x = [,,,,];
Šime Vidas
quelle
3
Das ist schlau. Es hat nicht die Flexibilität des Konstruktors, da Sie keine Variable zum Festlegen der Länge verwenden können, aber es beantwortet meine Frage so, wie ich sie ursprünglich formuliert habe, also +1.
Michael Martin-Smucker
12
Stellen Sie sich das für 300 Artikel vor, wenn die Leistung wirklich wichtig wäre!
Marco Luglio
9
Es gibt wahrscheinlich nicht viel Leistungsgewinn, wenn ein Array mit einer so geringen Größe vorab zugewiesen wird. Der Leistungsunterschied wird beim Erstellen größerer Arrays besser wahrgenommen. In diesen Fällen wäre es etwas überwältigend, sie mit Kommas zu initialisieren.
Marco Luglio
6
Ich denke, dass dies aufgrund des letzten Kommas, manchmal 4 und manchmal 5, zu unterschiedlichen Ergebnissen in verschiedenen Browsern führt, siehe stackoverflow.com/questions/7246618/…
jperelli
1
Wie wäre es var size = 42; var myArray = eval("["+",".repeat(size)+"]");? (Nicht so ernst;)
Xoxox
15

Ich bin überrascht, dass keine funktionale Lösung vorgeschlagen wurde, mit der Sie die Länge in einer Zeile festlegen können. Folgendes basiert auf UnderscoreJS:

var test = _.map(_.range(4), function () { return undefined; });
console.log(test.length);

Aus den oben genannten Gründen würde ich dies vermeiden, es sei denn, ich wollte das Array mit einem bestimmten Wert initialisieren. Es ist interessant festzustellen, dass es andere Bibliotheken gibt, die einen Bereich implementieren, einschließlich Lo-Dash und Lazy, die möglicherweise unterschiedliche Leistungsmerkmale aufweisen.

Christang
quelle
Der Unterstrich schwarze Magie wird hier wirklich nicht benötigt. Abhängigkeiten sind wie Zucker, es scheint zunächst süß, aber bevor Sie es wissen, bekommen Sie Diabetes.
Romain Vincent
9

Bitte, die Leute geben ihre alten Gewohnheiten noch nicht auf. Es gibt einen großen Geschwindigkeitsunterschied zwischen der einmaligen Zuweisung von Speicher und der Arbeit mit den Einträgen in diesem Array (wie bisher) und der mehrmaligen Zuweisung, wenn ein Array wächst (was das System zwangsläufig unter der Haube mit anderen vorgeschlagenen Methoden tut). .

Nichts davon ist natürlich wichtig, bis Sie mit größeren Arrays etwas Cooles machen möchten. Dann tut es.

Da es in JS derzeit noch keine Option zum Festlegen der Anfangskapazität eines Arrays zu geben scheint, verwende ich Folgendes ...

var newArrayWithSize = function(size) {
  this.standard = this.standard||[];
  for (var add = size-this.standard.length; add>0; add--) {
   this.standard.push(undefined);// or whatever
  }
  return this.standard.slice(0,size);
}

Es gibt Kompromisse:

  • Diese Methode dauert so lange wie die anderen für den ersten Aufruf der Funktion, aber sehr wenig Zeit für spätere Aufrufe (es sei denn, Sie fordern ein größeres Array an).
  • Das standardArray reserviert permanent so viel Speicherplatz wie das größte Array, nach dem Sie gefragt haben.

Aber wenn es zu dem passt, was Sie tun, kann es eine Auszahlung geben. Informelles Timing setzt

for (var n=10000;n>0;n--) {var b = newArrayWithSize(10000);b[0]=0;}

bei ziemlich hoher Geschwindigkeit (ungefähr 50 ms für die 10000, da es mit n = 1000000 ungefähr 5 Sekunden dauerte) und

for (var n=10000;n>0;n--) {
  var b = [];for (var add=10000;add>0;add--) {
    b.push(undefined);
  }
}

bei weit über einer Minute (ungefähr 90 Sekunden für den 10000 auf derselben Chromkonsole oder ungefähr 2000 Mal langsamer). Das ist nicht nur die Zuordnung, sondern auch die 10000 Pushs, for-Schleife usw.

wils
quelle
Wenn Sie jedes Mal, wenn Sie das Ende des Arrays erreichen, es duplizieren, ist die Komplexität beim Einfügen von n-Werten immer noch O (n), sodass es keinen Unterschied in der Komplexität gibt (aber langsamer ist).
Tomer Wolberg
Gut gefangen @TomerWolberg, ich habe meinen Wortlaut geändert. Es ist eine Frage, ob die Push-Methode eine höhere Komplexität aufweist als die Initialisierung / Kopie eines einzelnen Mitglieds nach Slice. AFAIK, dass beide konstante Zeit sind, zumindest könnten sie es sein, also habe ich stattdessen das Wort "Geschwindigkeit" verwendet.
Wils
8

(Dies war wahrscheinlich besser als Kommentar, wurde aber zu lang)

Nachdem ich dies gelesen hatte, war ich neugierig, ob die Vorzuweisung tatsächlich schneller war, weil es theoretisch so sein sollte. Dieser Blog gab jedoch einige Tipps, die davon abraten . Http://www.html5rocks.com/en/tutorials/speed/v8/ .

Da ich immer noch unsicher bin, habe ich es auf die Probe gestellt. Und wie sich herausstellt, scheint es tatsächlich langsamer zu sein.

var time = Date.now();
var temp = [];
for(var i=0;i<100000;i++){
    temp[i]=i;
}
console.log(Date.now()-time);


var time = Date.now();
var temp2 = new Array(100000);
for(var i=0;i<100000;i++){
    temp2[i] = i;
}
console.log(Date.now()-time); 

Dieser Code liefert nach einigen gelegentlichen Läufen Folgendes:

$ node main.js 
9
16
$ node main.js 
8
14
$ node main.js 
7
20
$ node main.js 
9
14
$ node main.js 
9
19
j03m
quelle
3
Interessant, das schien unerwartet, also machte ich einen JSPerf-Test . Die Chrome-Ergebnisse stimmen mit Ihren Knotentests überein, aber Firefox und IE sind etwas schneller, wenn Sie dem Array vorab Speicherplatz zuweisen.
Michael Martin-Smucker
1
@ MichaelMartin-Smucker Warte ... heißt das, dass V8 nicht vollständig optimiert und perfekt ist?!?!? : P
Zeb McCorkle
1
@ MichaelMartin-Smucker - Ich habe gerade Ihr jsperf in Chrome Version 42.0.2311.90 ausgeführt (um genau zu sein - Testen in Chrome 42.0.2311.90 32-Bit unter Windows Server 2008 R2 / 7 64-Bit) und das Array mit dynamischer Größe war 69% langsamer .
Yellen
1
Das Gleiche gilt. (Ich habe den ursprünglichen Knotentest geschrieben) In Chrome 42.0.2311.90 unter Windows war die dynamische Größe 81% langsamer :). Aber unsere ursprünglichen Tests waren jetzt vor über einem Jahr. Die Zeit rutscht weiter, rutscht ab ...
j03m
1
Faszinierend ... aus den Ergebnissen auf jsperf geht hervor, dass die vorab zugewiesene Version in Chrome 38 einen enormen Schub bekommen hat. Die Zukunft!
Michael Martin-Smucker
8
var arr=[];
arr[5]=0;
alert("length="+arr.length); // gives 6
user1067305
quelle
2
Ja, aber console.log (arr) gibt an, dass [5: 0]dies ein spärliches Array ist und wahrscheinlich nicht das, was gewünscht wird.
Dreftymac
7

Hier ist eine andere Lösung

var arr = Array.apply( null, { length: 4 } );
arr;  // [undefined, undefined, undefined, undefined] (in Chrome)
arr.length; // 4

Das erste Argument von apply()ist eine Objektbindung, die uns hier nicht wichtig ist, also setzen wir sie auf null.

Array.apply(..)ruft die Array(..)Funktion auf und verteilt den { length: 3 }Objektwert als Argumente.

zangw
quelle
Ich verstehe nicht, warum diese Antwort abgelehnt wurde. Es ist eigentlich ein schöner Hack. Das heißt, Sie können new Array(n)ein Array wie dieses nicht initialisieren new Array(n).map(function(notUsed,index){...}), aber mit diesem Ansatz können Sie es, wie @zangw erwähnt, tun. +1 von mir.
Victor.Palyvoda
3

Der Array-Konstruktor hat eine mehrdeutige Syntax , und JSLint verletzt schließlich nur Ihre Gefühle.

Wenn Ihr Beispielcode fehlerhaft ist, löst die zweite varAnweisung a aus SyntaxError. Sie legen die Eigenschaft lengthdes Arrays fest test, sodass keine weitere erforderlich ist var.

Was Ihre Optionen angeht, array.lengthist dies die einzige "saubere". Die Frage ist, warum müssen Sie die Größe überhaupt einstellen? Versuchen Sie, Ihren Code umzugestalten, um diese Abhängigkeit zu beseitigen.

Ivo Wetzel
quelle
Woops, gutes Auge auf diese Sekunde var test. Das war ein schlampiges Kopieren und Einfügen von meiner Seite.
Michael Martin-Smucker
@IvoWetzel, Sie möchten die Größe einstellen, um die Leistung zu verbessern. JS-Arrays sind dynamische Arrays . Wenn Sie die Größe (oder besser gesagt die Kapazität) nicht festlegen, weist JS ein Array mit Standardgröße zu. Wenn Sie dann mehr Elemente hinzufügen, als passen, muss das Array vergrößert werden. Dies bedeutet, dass es intern ein neues Array zuweist und dann alle Elemente kopiert.
Domi
3

Angenommen, die Länge des Arrays ist konstant. In Javascript tun wir Folgendes:

const intialArray = new Array(specify the value);

Mohan Babu
quelle
2

Wie oben erläutert, ist die Verwendung new Array(size)etwas gefährlich. Platzieren Sie es nicht direkt, sondern in einer "Array Creator-Funktion". Sie können leicht sicherstellen, dass diese Funktion fehlerfrei ist und Sie vermeiden die Gefahr eines new Array(size)direkten Anrufs . Sie können ihm auch einen optionalen Standardanfangswert geben. Diese createArrayFunktion macht genau das:

function createArray(size, defaultVal) {
    var arr = new Array(size);
    if (arguments.length == 2) {
        // optional default value
        for (int i = 0; i < size; ++i) {
            arr[i] = defaultVal;
        }
    }
    return arr;
}
Domi
quelle
1

In den meisten Antworten wird es filldem Array empfohlen, da sonst "Sie nicht darüber iterieren können" , aber dies ist nicht wahr. Sie können ein leeres Array iterieren, nur nicht mit forEach. Während Schleifen, für Schleifen und für i Schleifen funktionieren gut.

const count = Array(5);

Funktioniert nicht.

console.log('---for each loop:---');
count.forEach((empty, index) => {
    console.log(`counting ${index}`);
});

Diese Arbeit:

console.log('---for of loop:---');
for (let [index, empty] of count.entries()) {
  console.log(`counting for of loop ${index}`);
}

console.log('---for i loop:---');
for (let i = 0, il = count.length; i < il; ++i) {
  console.log(`counting for i loop ${i}`);
}

console.log('---while loop:---');
let index = 0;
while (index < count.length) { 
  console.log(`counting while loop ${index}`); 
  index++; 
}

Überprüfen Sie diese Geige anhand der obigen Beispiele.

Auch Winkel *ngForfunktionieren gut mit einem leeren Array:

<li *ngFor="let empty of count; let i = index" [ngClass]="
  <span>Counting with *ngFor {{i}}</span>
</li>
Verwelken
quelle
-1

Sie können die Array-Länge mithilfe von festlegen array.length = youValue

So wäre es

var myArray = [];
myArray.length = yourValue;
Ajoposor
quelle
-3

Der Grund, den Sie nicht verwenden sollten, new Arraywird durch diesen Code demonstriert:

var Array = function () {};

var x = new Array(4);

alert(x.length);  // undefined...

Ein anderer Code könnte mit der Array-Variablen in Konflikt geraten. Ich weiß, es ist ein bisschen weit hergeholt, dass irgendjemand solchen Code schreiben würde, aber trotzdem ...

Wie Felix King sagte, ist die Benutzeroberfläche etwas inkonsistent und kann zu einigen sehr schwer auffindbaren Fehlern führen.

Wenn Sie ein Array mit der Länge = x new Array(x)möchten , das mit undefiniert gefüllt ist (wie dies der Fall wäre), können Sie Folgendes tun:

var x = 4;
var myArray = [];
myArray[x - 1] = undefined;

alert(myArray.length); // 4
nickf
quelle
48
Nach dieser Argumentation sollten Sie nicht verwenden , alertund undefined, weil ein anderer Code könnte Chaos mit ihnen. Das zweite Beispiel ist weniger lesbar als new Array(4)und liefert nicht das gleiche Ergebnis: jsfiddle.net/73fKd
Alexey Lebedev
25
Diese Antwort ist bizarr
Marco Demaio
6
Sie können nicht vermeiden, dass Leute mit globalen Objekten in JavaScript herumspielen. Tun Sie das einfach nicht und verwenden Sie keine Frameworks, in denen die Leute das tun.
Richard Connamacher
In der Chrome-Repl aktuell: j = neues Array (4); Länge; // ergibt 4
Parris