Initialisieren eines Arrays mit einem einzelnen Wert

Gibt es eine kompaktere Möglichkeit, diese Art der Initialisierung durchzuführen?

for (var i = 0; i < arraySize; i++) array[i] = value;

while(arraySize--) array.push(value);

keine Initialisierung (die ich kenne)

Aktualisieren

Seit wir diese Antwort vor 4 Jahren veröffentlicht haben, scheinen die Leute immer wieder hierher zu kommen, um diese Antwort zu erhalten. Für Benchmarking-Zwecke habe ich einen JSPerf mit verschiedenen Lösungen erstellt.

Die obige Lösung ist nicht die schnellste, obwohl sie kurz ist. Um am gleichen kurzen Stil festzuhalten, aber mit einer besseren Leistung:

while(size--) array[size] = value;

Update Feb 2016 Aktualisiert die JSPerf mit einer neuen Revision mit mehr Testfällen.

Wenn Leistung keine Rolle spielt und Sie einen Einzeiler wünschen:

var value = 1234, // can be replaced by a fixed value
    size  = 1000, // can be replaced by a fixed value
    array = Array.apply(null,{length: size}).map(function() { return value; });

Eine leistungsfähigere Lösung (in einer, schmutzigen, Zeile): Beachten Sie: Dies ersetzt vorhandene Variablen für Wert, Größe und i im Bereich

for(var i = 0, value = 1234, size = 1000, array = new Array(1000); i < size; i++) array[i] = value;

Ein kurzer Weg wäre:

var arr = Array(arraySize).fill(value);

Würde machen arr = Array [ 0, 0, 0, 0, 0 ]wenn arraySize == 5und value == 0zum Beispiel.

Ich finde das schön, kurz und elegant:

// assuming `value` is what you want to fill the array with
// and `arraySize` is the size of the array
Array(arraySize).fill(value);

Das OP scheint nach Kompaktheit in einem Einweg-Szenario über Effizienz und Wiederverwendbarkeit zu streben. Für andere, die Effizienz suchen, ist hier eine Optimierung, die noch nicht erwähnt wurde. Da Sie die Länge des Arrays im Voraus kennen, legen Sie sie fest, bevor Sie die Werte zuweisen. Andernfalls wird die Größe des Arrays im laufenden Betrieb wiederholt geändert - nicht ideal!

function initArray(length, value) {
    var arr = [], i = 0;
    arr.length = length;
    while (i < length) { arr[i++] = value; }
    return arr;
}

var data = initArray(1000000, false);

Dies ist nicht so kompakt, aber wohl direkter.

array = Array.apply(null, new Array(arraySize)).map(function () {return value;});

Dies ist wahrscheinlich nicht besser als eine der oben genannten Techniken, aber es macht Spaß ...

var a = new Array(10).join('0').split('').map(function(e) {return parseInt(e, 10);})

Dies ist eine alte Frage, aber ich verwende sie in modernen JS:

[...new Array(1000000)].map(()=>42);

Aus Effizienzgründen würde ich vermeiden push. Also einfach

for (var i = 0; i < arraySize; i++) array[i] = value; 

Für IE10:

array = new Array(arraySize); 
for (var i = 0; i < arraySize; i++) array[i] = value; 

Bearbeiten: geändert wie in den Kommentaren beschrieben.

Wenn Sie dies mehrmals tun müssen, können Sie jederzeit eine Funktion schreiben:

function makeArray(howMany, value){
    var output = [];
    while(howMany--){
        output.push(value);
    }
    return output;
}

var data = makeArray(40, "Foo");

Und nur der Vollständigkeit halber (das Herumspielen mit dem Prototyp von eingebauten Objekten ist oft keine gute Idee):

Array.prototype.fill = function(howMany, value){
    while(howMany--){
        this.push(value);
    }
}

So können Sie jetzt:

var data = [];
data.fill(40, "Foo");

Update: Ich habe gerade Ihre Notiz über arraySizeeine Konstante oder ein Literal gesehen. Wenn ja, ersetzen Sie einfach alle while(howMany--)durch gute alte for(var i=0; i<howMany; i++).

Stolperte über dieses, während ich Array-Methoden in einem Flugzeug erforschte. Ohhh, die Orte, an die wir gehen, wenn wir gelangweilt sind. :) :)

var initializedArray = new Array(30).join(null).split(null).map(function(item, index){
  return index;
});

.map()und nullfür den Sieg! Ich mag null, weil das Übergeben eines Strings wie oben mit '0' oder einem anderen Wert verwirrend ist. Ich denke, das ist deutlicher, dass wir etwas anderes machen.

Beachten Sie, dass .map()nicht initialisierte Werte übersprungen werden. Deshalb new Array(30).map(function(item, index){return index});funktioniert das nicht. Die neue .fill()Methode wird bevorzugt, sofern verfügbar. Die Browserunterstützung sollte jedoch ab sofort beachtet werden 23.08.2015 beachtet werden .

Desktop (Basisunterstützung)

• Chrome 45 (36 1 )
• Firefox (Gecko) 31 (31)
• Internet Explorer Nicht unterstützt
• Opera Wird nicht unterstützt
• Safari 7.1

Von MDN :

[1, 2, 3].fill(4);               // [4, 4, 4]
[1, 2, 3].fill(4, 1);            // [1, 4, 4]
[1, 2, 3].fill(4, 1, 2);         // [1, 4, 3]
[1, 2, 3].fill(4, 1, 1);         // [1, 2, 3]
[1, 2, 3].fill(4, -3, -2);       // [4, 2, 3]
[1, 2, 3].fill(4, NaN, NaN);     // [1, 2, 3]
Array(3).fill(4);                // [4, 4, 4]
[].fill.call({ length: 3 }, 4);  // {0: 4, 1: 4, 2: 4, length: 3}