Ich suche nach Alternativen zu den folgenden, um ein JavaScript-Array mit 1 bis N zu erstellen, wobei N nur zur Laufzeit bekannt ist.

var foo = [];

for (var i = 1; i <= N; i++) {
   foo.push(i);
}

Für mich scheint es einen Weg zu geben, dies ohne die Schleife zu tun.

Wenn ich bekomme, wonach Sie suchen, möchten Sie eine Reihe von Zahlen 1..n, die Sie später durchlaufen können.

Wenn dies alles ist, was Sie brauchen, können Sie dies stattdessen tun?

var foo = new Array(45); // create an empty array with length 45

dann, wenn Sie es verwenden möchten ... (nicht optimiert, nur zum Beispiel)

for(var i = 0; i < foo.length; i++){
  document.write('Item: ' + (i + 1) + ' of ' + foo.length + '<br/>'); 
}

Wenn Sie beispielsweise nichts im Array speichern müssen, benötigen Sie nur einen Container mit der richtigen Länge, über den Sie iterieren können. Dies ist möglicherweise einfacher.

Sehen Sie es hier in Aktion: http://jsfiddle.net/3kcvm/

In ES6 mit den Methoden Array from () und keys () .

Array.from(Array(10).keys())
//=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Kürzere Version mit Spread-Operator .

[...Array(10).keys()]
//=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Sie können dies tun:

var N = 10; 
Array.apply(null, {length: N}).map(Number.call, Number)

Ergebnis: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

oder mit zufälligen Werten:

Array.apply(null, {length: N}).map(Function.call, Math.random)

Ergebnis: [0,7082694901619107, 0,9572225909214467, 0,8586748542729765, 0,8653848143294454, 0,008339877473190427, 0,9911756622605026, 0,8133423360995948, 0,8377588465809822, 0,8377575

Erläuterung

Beachten Sie zunächst, dass dies Number.call(undefined, N)äquivalent zu ist Number(N), was gerade zurückgegeben wird N. Wir werden diese Tatsache später nutzen.

Array.apply(null, [undefined, undefined, undefined])ist äquivalent zu Array(undefined, undefined, undefined), das ein Array mit drei Elementen erzeugt und undefinedjedem Element zuweist .

Wie kann man das auf N Elemente verallgemeinern ? Überlegen Sie, wie es Array()funktioniert, was ungefähr so ​​aussieht:

function Array() {
    if ( arguments.length == 1 &&
         'number' === typeof arguments[0] &&
         arguments[0] >= 0 && arguments &&
         arguments[0] < 1 << 32 ) {
        return [ … ];  // array of length arguments[0], generated by native code
    }
    var a = [];
    for (var i = 0; i < arguments.length; i++) {
        a.push(arguments[i]);
    }
    return a;
}

Da ECMAScript 5 , Function.prototype.apply(thisArg, argsArray)akzeptiert auch eine Ente typisierte Array-ähnliches Objekt als zweiten Parameter. Wenn wir aufrufen Array.apply(null, { length: N }), wird es ausgeführt

function Array() {
    var a = [];
    for (var i = 0; i < /* arguments.length = */ N; i++) {
        a.push(/* arguments[i] = */ undefined);
    }
    return a;
}

Jetzt haben wir ein N- Element-Array, auf das jedes Element gesetzt ist undefined. Wenn wir es aufrufen .map(callback, thisArg), wird jedes Element auf das Ergebnis von gesetzt callback.call(thisArg, element, index, array). Daher [undefined, undefined, …, undefined].map(Number.call, Number)würde jedes Element zugeordnet werden (Number.call).call(Number, undefined, index, array), was dasselbe ist Number.call(undefined, index, array), das, wie wir zuvor beobachtet haben, ausgewertet wird index. Damit ist das Array vervollständigt, dessen Elemente mit ihrem Index übereinstimmen.

Warum sich die Mühe machen Array.apply(null, {length: N})anstatt nur Array(N)? Schließlich würden beide Ausdrücke ein N- Element-Array undefinierter Elemente ergeben. Der Unterschied ist , dass in dem früheren Ausdruck, wobei jedes Element explizit gesetzt zu undefinierten, wohingegen in den letzteren, wobei jedes Element nie gesetzt wurde. Nach der Dokumentation von .map():

callbackwird nur für Indizes des Arrays aufgerufen, denen Werte zugewiesen wurden; Es wird nicht für Indizes aufgerufen, die gelöscht wurden oder denen nie Werte zugewiesen wurden.

Daher Array(N)ist nicht ausreichend; Array(N).map(Number.call, Number)würde zu einem nicht initialisierten Array der Länge N führen .

Kompatibilität

Da diese Technik auf dem Function.prototype.apply()in ECMAScript 5 angegebenen Verhalten beruht , funktioniert sie in Browsern vor ECMAScript 5 wie Chrome 14 und Internet Explorer 9 nicht.

Mehrere Möglichkeiten mit ES6

Verwenden des Spread-Operators ( ...) und der Keys-Methode

[ ...Array(N).keys() ].map( i => i+1);

Füllen / Karte

Array(N).fill().map((_, i) => i+1);

Array.from

Array.from(Array(N), (_, i) => i+1)

Array.from und { length: N }hack

Array.from({ length: N }, (_, i) => i+1)

Hinweis zur verallgemeinerten Form

Alle Formen oben produzieren können Arrays initialisiert ziemlich jede gewünschten Wert durch Änderung i+1erforderlich ist, um die Expression (beispielsweise i*2, -i, 1+i*2, i%2und etc.). Wenn Ausdruck durch eine Funktion ausgedrückt werden kann, wird fdie erste Form einfach

[ ...Array(N).keys() ].map(f)

Beispiele:

Array.from({length: 5}, (v, k) => k+1); 
// [1,2,3,4,5]

Da das Array initialisiert wird undefinedan jeder Position, der Wert v wirdundefined

Beispiel für alle Formulare

let demo= (N) => {
  console.log(
    [ ...Array(N).keys() ].map(( i) => i+1),
    Array(N).fill().map((_, i) => i+1) ,
    Array.from(Array(N), (_, i) => i+1),
    Array.from({ length: N }, (_, i) => i+1)
  )
}

demo(5)

Allgemeineres Beispiel mit Funktion benutzerdefinierten initialiser fdh

[ ...Array(N).keys() ].map((i) => f(i))

oder noch einfacher

[ ...Array(N).keys() ].map(f)

let demo= (N,f) => {
  console.log(
    [ ...Array(N).keys() ].map(f),
    Array(N).fill().map((_, i) => f(i)) ,
    Array.from(Array(N), (_, i) => f(i)),
    Array.from({ length: N }, (_, i) => f(i))
  )
}

demo(5, i=>2*i+1)

Arrays verwalten von Natur aus ihre Längen. Während sie durchlaufen werden, können ihre Indizes im Speicher gehalten und an diesem Punkt referenziert werden. Wenn ein Zufallsindex bekannt sein muss, kann die indexOfMethode verwendet werden.

Für Ihre Anforderungen möchten Sie möglicherweise nur ein Array mit einer bestimmten Größe deklarieren:

var foo = new Array(N);   // where N is a positive integer

/* this will create an array of size, N, primarily for memory allocation, 
   but does not create any defined values

   foo.length                                // size of Array
   foo[ Math.floor(foo.length/2) ] = 'value' // places value in the middle of the array
*/

ES6

Ausbreitung

Mithilfe des Spread-Operators ( ...) und der keysMethode können Sie ein temporäres Array der Größe N erstellen, um die Indizes zu erstellen, und anschließend ein neues Array, das Ihrer Variablen zugewiesen werden kann:

var foo = [ ...Array(N).keys() ];

Füllen / Karte

Sie können zuerst die Größe des Arrays erstellen, das Sie benötigen, es mit undefiniert füllen und dann mit ein neues Array erstellen map, das jedes Element auf den Index setzt.

var foo = Array(N).fill().map((v,i)=>i);

Array.from

Dies sollte auf die Länge der Größe N initialisiert und das Array in einem Durchgang gefüllt werden.

Array.from({ length: N }, (v, i) => i)

Anstelle der Kommentare und der Verwirrung gibt es einige Optionen, wenn Sie die Werte von 1..N in den obigen Beispielen wirklich erfassen möchten:

1. Wenn der Index verfügbar ist, können Sie ihn einfach um eins erhöhen (z ++i. B. ).

2. In Fällen, in denen der Index nicht verwendet wird - und möglicherweise auf effizientere Weise -, müssen Sie Ihr Array erstellen, aber N für N + 1 stellen und dann die Vorderseite verschieben.

   Wenn Sie also 100 Zahlen wünschen:

   let arr; (arr=[ ...Array(101).keys() ]).shift()

In ES6 können Sie Folgendes tun:

Array(N).fill().map((e,i)=>i+1);

http://jsbin.com/molabiluwa/edit?js,console

Bearbeiten: Geändert Array(45)zu, Array(N)seit Sie die Frage aktualisiert haben.

console.log(
  Array(45).fill(0).map((e,i)=>i+1)
);

Verwenden Sie die sehr beliebte Methode Underscore _.range

// _.range([start], stop, [step])

_.range(10); // => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
_.range(1, 11); // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
_.range(0, 30, 5); // => [0, 5, 10, 15, 20, 25]
_.range(0, -10, -1); //  => [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
_.range(0); // => []

function range(start, end) {
    var foo = [];
    for (var i = start; i <= end; i++) {
        foo.push(i);
    }
    return foo;
}

Dann angerufen von

var foo = range(1, 5);

Es gibt keine integrierte Möglichkeit, dies in Javascript zu tun, aber es ist eine vollkommen gültige Dienstprogrammfunktion, die Sie erstellen können, wenn Sie sie mehrmals ausführen müssen.

Bearbeiten: Meiner Meinung nach ist das Folgende eine bessere Bereichsfunktion. Vielleicht nur, weil ich von LINQ voreingenommen bin, aber ich denke, dass es in mehr Fällen nützlicher ist. Ihr Kilometerstand kann variieren.

function range(start, count) {
    if(arguments.length == 1) {
        count = start;
        start = 0;
    }

    var foo = [];
    for (var i = 0; i < count; i++) {
        foo.push(start + i);
    }
    return foo;
}

Der schnellste Weg, eine ArrayVersion 8 auszufüllen, ist:

[...Array(5)].map((_,i) => i);

Ergebnis wird sein: [0, 1, 2, 3, 4]

Diese Frage hat viele komplizierte Antworten, aber einen einfachen Einzeiler:

[...Array(255).keys()].map(x => x + 1)

Auch wenn das Obige kurz (und ordentlich) zu schreiben ist, denke ich, dass das Folgende etwas schneller ist (für eine maximale Länge von:

127, Int8,

255, Uint8,

32,767, Int16,

65,535, Uint16,

2,147,483,647, Int32,

4,294,967,295, Uint32.

(basierend auf den maximalen Ganzzahlwerten ), auch hier mehr zu typisierten Arrays ):

(new Uint8Array(255)).map(($,i) => i + 1);

Obwohl diese Lösung auch nicht so ideal ist, weil sie zwei Arrays erstellt und die zusätzliche Variablendeklaration "$" verwendet (nicht sicher, wie man das mit dieser Methode umgehen kann). Ich denke, die folgende Lösung ist der absolut schnellste Weg, dies zu tun:

for(var i = 0, arr = new Uint8Array(255); i < arr.length; i++) arr[i] = i + 1;

Nach dieser Anweisung können Sie jederzeit die Variable "arr" im aktuellen Bereich verwenden.

Wenn Sie eine einfache Funktion daraus machen möchten (mit einigen grundlegenden Überprüfungen):

function range(min, max) {
    min = min && min.constructor == Number ? min : 0;
    !(max && max.constructor == Number && max > min) && // boolean statements can also be used with void return types, like a one-line if statement.
        ((max = min) & (min = 0));  //if there is a "max" argument specified, then first check if its a number and if its graeter than min: if so, stay the same; if not, then consider it as if there is no "max" in the first place, and "max" becomes "min" (and min becomes 0 by default)

    for(var i = 0, arr = new (
        max < 128 ? Int8Array : 
        max < 256 ? Uint8Array :
        max < 32768 ? Int16Array : 
        max < 65536 ? Uint16Array :
        max < 2147483648 ? Int32Array :
        max < 4294967296 ? Uint32Array : 
        Array
    )(max - min); i < arr.length; i++) arr[i] = i + min;
    return arr;
}



//and you can loop through it easily using array methods if you want
range(1,11).forEach(x => console.log(x));

//or if you're used to pythons `for...in` you can do a similar thing with `for...of` if you want the individual values:
for(i of range(2020,2025)) console.log(i);

//or if you really want to use `for..in`, you can, but then you will only be accessing the keys:

for(k in range(25,30)) console.log(k);

console.log(
    range(1,128).constructor.name,
    range(200).constructor.name,
    range(400,900).constructor.name,
    range(33333).constructor.name,
    range(823, 100000).constructor.name,
    range(10,4) // when the "min" argument is greater than the "max", then it just considers it as if there is no "max", and the new max becomes "min", and "min" becomes 0, as if "max" was never even written
);

Mit der obigen Funktion wird der obige super langsame "einfache Einzeiler" zum superschnellen, sogar kürzeren:

range(1,14000);

Sie können dies verwenden:

new Array(/*any number which you want*/)
    .join().split(',')
    .map(function(item, index){ return ++index;})

zum Beispiel

new Array(10)
    .join().split(',')
    .map(function(item, index){ return ++index;})

erstellt folgendes Array:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

ES6 das wird den Trick machen:

[...Array(12).keys()]

Überprüfen Sie das Ergebnis:

[...Array(12).keys()].map(number => console.log(number))

Wenn Sie zufällig d3.js verwenden in Ihrer App verwenden, wie ich es bin, bietet D3 eine , die dies für Sie erledigt.

Um ein Array von 0 bis 4 zu erhalten, ist es so einfach wie:

d3.range(5)
[0, 1, 2, 3, 4]

und um ein Array von 1 bis 5 zu erhalten, wie Sie es angefordert haben:

d3.range(1, 5+1)
[1, 2, 3, 4, 5]

Weitere Informationen finden Sie in diesem Tutorial .

Verwenden des Spread-Operators ES2015 / ES6

[...Array(10)].map((_, i) => i + 1)

console.log([...Array(10)].map((_, i) => i + 1))

Dies ist wahrscheinlich der schnellste Weg, um ein Array von Zahlen zu generieren

Kürzeste

var a=[],b=N;while(b--)a[b]=b+1;

In der Reihe

var arr=(function(a,b){while(a--)b[a]=a;return b})(10,[]);
//arr=[0,1,2,3,4,5,6,7,8,9]

Wenn Sie von 1 beginnen möchten

var arr=(function(a,b){while(a--)b[a]=a+1;return b})(10,[]);
//arr=[1,2,3,4,5,6,7,8,9,10]

Willst du eine Funktion?

function range(a,b,c){c=[];while(a--)c[a]=a+b;return c}; //length,start,placeholder
var arr=range(10,5);
//arr=[5,6,7,8,9,10,11,12,13,14]

WARUM?

1. while ist die schnellste Schleife

2. Direkte Einstellung ist schneller als push

3. [] ist schneller als new Array(10)

4. es ist kurz ... schau dir den ersten Code an. Dann schauen Sie sich alle anderen Funktionen hier an.

Wenn Sie mögen , kann nicht leben , ohne für

for(var a=[],b=7;b>0;a[--b]=b+1); //a=[1,2,3,4,5,6,7]

oder

for(var a=[],b=7;b--;a[b]=b+1); //a=[1,2,3,4,5,6,7]

Der neue Weg zum Füllen Arrayist:

const array = [...Array(5).keys()]
console.log(array)

Ergebnis wird sein: [0, 1, 2, 3, 4]

Wenn Sie lodash verwenden, können Sie _.range verwenden :

_.range([start=0], end, [step=1])

Erstellt ein Array von Zahlen (positiv und / oder negativ), die vom Start bis zum Ende reichen, diese jedoch nicht einschließen. Ein Schritt von -1 wird verwendet, wenn ein negativer Start ohne Ende oder Schritt angegeben wird. Wenn end nicht angegeben ist, beginnt es mit start und wird dann auf 0 gesetzt.

Beispiele:

_.range(4);
// ➜ [0, 1, 2, 3]

_.range(-4);
// ➜ [0, -1, -2, -3]

_.range(1, 5);
// ➜ [1, 2, 3, 4]

_.range(0, 20, 5);
// ➜ [0, 5, 10, 15]

_.range(0, -4, -1);
// ➜ [0, -1, -2, -3]

_.range(1, 4, 0);
// ➜ [1, 1, 1]

_.range(0);
// ➜ []

Mit ES6 können Sie Folgendes tun:

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

Abschlussbericht .. Drrruummm Rolll -

Dies ist der kürzeste Code zum Generieren eines Arrays der Größe N (hier 10) ohne Verwendung von ES6 . Die obige Version von Cocco ist nah, aber nicht die kürzeste.

(function(n){for(a=[];n--;a[n]=n+1);return a})(10)

Der unbestrittene Gewinner dieses Code-Golfs (Wettbewerb zur Lösung eines bestimmten Problems in den wenigsten Bytes des Quellcodes) ist Niko Ruotsalainen . Verwenden des Array-Konstruktors und des ES6-Spread-Operators . (Der größte Teil der ES6-Syntax ist gültiges TypeScript, das Folgende jedoch nicht. Seien Sie also bei der Verwendung vorsichtig.)

[...Array(10).keys()]

Es gibt eine andere Möglichkeit in ES6, Array.from zu verwenden, das zwei Argumente akzeptiert. Das erste ist ein arrayLike (in diesem Fall ein Objekt mit lengthEigenschaft) und das zweite ist eine Zuordnungsfunktion (in diesem Fall ordnen wir das Element seinem Index zu).

Array.from({length:10}, (v,i) => i)

Dies ist kürzer und kann für andere Sequenzen wie das Generieren von geraden Zahlen verwendet werden

Array.from({length:10}, (v,i) => i*2)

Dies hat auch eine bessere Leistung als die meisten anderen Methoden, da es das Array nur einmal durchläuft. Überprüfen Sie das Snippit für einige Vergleiche

// open the dev console to see results

count = 100000

console.time("from object")
for (let i = 0; i<count; i++) {
  range = Array.from({length:10}, (v,i) => i )
}
console.timeEnd("from object")

console.time("from keys")
for (let i =0; i<count; i++) {
  range = Array.from(Array(10).keys())
}
console.timeEnd("from keys")

console.time("apply")
for (let i = 0; i<count; i++) {
  range = Array.apply(null, { length: 10 }).map(function(element, index) { return index; })
}
console.timeEnd("apply")

Verwenden neuer Array-Methoden und => Funktionssyntax aus dem ES6-Standard (zum Zeitpunkt des Schreibens nur Firefox).

Durch Füllen von Löchern mit undefined:

Array(N).fill().map((_, i) => i + 1);

Array.fromverwandelt "Löcher" in undefinedso Array.mapfunktioniert wie erwartet:

Array.from(Array(5)).map((_, i) => i + 1)

for(var i,a=[i=0];i<10;a[i++]=i);

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

In ES6:

Array.from({length: 1000}, (_, i) => i);

ES5:

Array.apply(0, {length: 1000}).map(function(x,i){return i});

Nur ein weiterer ES6 Version.

Unter Verwendung des Array.fromzweiten optionalen Arguments:

Array.from (arrayLike [, mapFn [, thisArg]])

Wir können das nummerierte Array aus den leeren Array(10)Positionen erstellen :

Array.from(Array(10), (_, i) => i)

var arr = Array.from(Array(10), (_, i) => i);
document.write(arr);

Es scheint, dass der einzige Geschmack, der derzeit nicht in dieser ziemlich vollständigen Liste von Antworten enthalten ist, ein Generator ist. um dem abzuhelfen:

const gen = N => [...(function*(){let i=0;while(i<N)yield i++})()]

welches so verwendet werden kann:

gen(4) // [0,1,2,3]

Das Schöne daran ist, dass Sie nicht nur inkrementieren müssen ... Um sich von der Antwort von igor-shubin inspirieren zu lassen, können Sie ganz einfach eine Reihe von Zufällen erstellen:

const gen = N => [...(function*(){let i=0;
  while(i++<N) yield Math.random()
})()]

Und anstatt etwas langwierig operativ teures wie:

const slow = N => new Array(N).join().split(',').map((e,i)=>i*5)
// [0,5,10,15,...]

Sie könnten stattdessen tun:

const fast = N => [...(function*(){let i=0;while(i++<N)yield i*5})()]

Sie können Array Fill und Map von Es6 aus verwenden. Genau wie einige wenige Leute in den Antworten vorgeschlagen haben, die sie auf diese Frage gegeben haben. Nachfolgend einige Beispiele:

Example-One: Array(10).fill(0).map((e,i)=>i+1)

Result-One: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Example-Two: Array(100/10).fill(0).map((e,i)=>(i*10)+10)

Result-Two:[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

Ich bevorzuge dies, weil ich es einfach und einfacher finde.

Array.from({ length: (stop - start) / step + 1}, (_, i) => start + (i * step));

Quelle: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from

Verwenden von ES6

const generateArray = n => [...Array(n)].map((_, index) => index + 1);

Object.keys(Array.apply(0, Array(3))).map(Number)

Rückgabe [0, 1, 2]. Sehr ähnlich zu Igor Shubins ausgezeichneter Antwort , aber mit etwas weniger Tricks (und einem Charakter länger).

Erläuterung:

• Array(3) // [undefined × 3]Generieren Sie ein Array mit der Länge n = 3. Leider ist dieses Array für uns fast nutzlos, also müssen wir…
• Array.apply(0,Array(3)) // [undefined, undefined, undefined]Machen Sie das Array iterierbar. Hinweis: Null ist häufiger als das erste Argument von apply, aber 0 ist kürzer.
• Object.keys(Array.apply(0,Array(3))) // ['0', '1', '2'] Holen Sie sich dann die Schlüssel des Arrays (funktioniert, weil Arrays der Typ des Arrays sind, ist ein Objekt mit Indizes für Schlüssel.
• Object.keys(Array.apply(0,Array(3))).map(Number) // [0, 1, 2] und ordnen Sie die Tasten zu und konvertieren Sie Zeichenfolgen in Zahlen.