webentwicklung-frage-antwort-db.com.de

Erstellen Sie ein JavaScript-Array mit 1 ... N

Ich suche nach Alternativen zu den unten genannten, 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 fühlt es sich an, als müsste es einen Weg geben, dies ohne die Schleife zu tun.

723
Godders

Wenn ich das bekomme, was Sie suchen, möchten Sie ein Zahlenfeld 1..n, das Sie später durchlaufen können.

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

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

dann, wenn Sie es verwenden wollen ... (nicht optimiert, nur zum Beispiel)

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

z.B. Wenn Sie nichts im Array store brauchen, brauchen Sie nur einen Container der richtigen Länge, den Sie durchlaufen können.

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

243
scunliffe

Das kannst du 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.5577575915958732, 0.16363654541783035

Erläuterung

Beachten Sie zunächst, dass Number.call(undefined, N) äquivalent zu Number(N) ist, das nur N zurückgibt. 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 jedem Element undefined zuweist.

Wie können Sie das auf N Elemente verallgemeinern? Betrachten Sie, wie Array() funktioniert, was in etwa 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;
}

(Seit ECMAScript 5 , Function.prototype.apply(thisArg, argsArray) akzeptiert auch ein Array-ähnliches Objekt vom Typ Ente als zweiten Parameter. Wenn wir Array.apply(null, { length: N }) aufrufen, 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, bei dem jedes Element auf undefined gesetzt ist. Wenn wir .map(callback, thisArg) aufrufen, wird jedes Element auf das Ergebnis von callback.call(thisArg, element, index, array) gesetzt. Daher würde [undefined, undefined, …, undefined].map(Number.call, Number) jedes Element auf (Number.call).call(Number, undefined, index, array) abbilden. Dies ist das Gleiche wie Number.call(undefined, index, array), das wie bereits erwähnt zu index ausgewertet wird. Damit ist das Array fertiggestellt, dessen Elemente mit ihrem Index übereinstimmen.

Warum durch die Mühe von Array.apply(null, {length: N}) gehen, anstatt nur Array(N)? Schließlich würden beide Ausdrücke ein N -Element-Array von undefinierten Elementen ergeben. Der Unterschied besteht darin, dass im ersten Ausdruck jedes Element explizit set auf undefined gesetzt ist, wohingegen im letzten Element jedes Element nie gesetzt wurde. Gemäß der Dokumentation von .map() :

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

Daher ist Array(N) 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 Verhalten von Function.prototype.apply() basiert, das in ECMAScript 5 angegeben ist, wird nicht funktionieren in Browsern vor ECMAScript 5 wie Chrome 14 und Internet Explorer 9 verwendet.

746
Igor Shubin

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

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]
679

Einfacher & kurzer Weg in ES6 :

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

Also:

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

const range = (N) => Array.from({length: N}, (v, k) => k+1) ;

console.log(
  range(5)
)

246
Abdennour TOUMI

In ES6 können Sie:

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

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

Bearbeiten: Array(45) wurde in Array(N) geändert, seitdem Sie die Frage aktualisiert haben.

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

Ich weiß, Ihre Frage fordert, ein Array numerisch auszufüllen, aber ich bin nicht sicher, warum Sie dies tun möchten. 

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


Für Ihre Anforderungen möchten Sie vielleicht 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

Verbreitung

Wenn Sie den Spread-Operator (...) und die keys-Methode verwenden, 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 gewünschten Arrays erstellen, es mit undefined füllen und dann mit map ein neues Array erstellen, wodurch jedes Element auf den Index gesetzt wird.

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

Array.from

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

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

Verwenden Sie die sehr beliebte Underscore _.range-Methode

// _.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); // => []
99
Evan
function range(start, end) {
    var foo = [];
    for (var i = start; i <= end; i++) {
        foo.Push(i);
    }
    return foo;
}

Dann von angerufen

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 erstellt werden kann, wenn Sie es mehr als einmal tun müssen.

Edit: Meiner Meinung nach ist das folgende eine bessere Range-Funktion. Vielleicht, weil ich von LINQ voreingenommen bin, aber ich denke, dass es in mehr Fällen nützlicher ist. Ihre Laufleistung 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;
}
61
Ian Henry

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]
43
nktssh

der schnellste Weg, einen Array in Version 8 auszufüllen, ist:

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

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

43
аlex dykyі

ES6 das wird den Trick machen:

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

schauen Sie sich das Ergebnis an:

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

Verwenden des Spread-Operators ES2015/ES6

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

Wenn Sie in Ihrer App d3.js verwenden, wie ich bin, bietet D3 eine Hilfsfunktion, 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 gewünscht haben:

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

Check out dieses Tutorial für weitere Informationen.

38
Tyler Rick

Dies ist wahrscheinlich der schnellste Weg, um ein Zahlenfeld 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 an 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 ... schauen Sie sich den ersten Code an. dann schau dir alle anderen Funktionen hier an.

Wenn du nicht magst 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]
36
cocco

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

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

Erstellt eine Reihe von Zahlen (positiv und/oder negativ), die vom Anfang bis zum Ende, jedoch nicht einschließlich, fortschreiten. 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);
// ➜ []
30
Hongbo Miao

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 max Integer-Werten ), hier auch mehr zu Typed 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 (ich bin mir nicht sicher, wie ich 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 Gültigkeitsbereich 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
);
27
bluejayke

die neue Möglichkeit, Array zu füllen, ist:

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

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

25
аlex dykyі

Zusammenfassung der Abschlussberichte .. Drrruummm Rolll -

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

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

Der unbestrittene Gewinner dieses Code-Golfs (Wettbewerb um ein bestimmtes Problem in den wenigsten Bytes des Quellcodes zu lösen) ist Niko Ruotsalainen . Array Constructor und ES6-Spread-Operator verwenden. (Der Großteil der ES6-Syntax ist gültiges TypeScript, Folgendes ist jedoch nicht der Fall. Seien Sie daher vorsichtig, wenn Sie es verwenden.) 

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

Es gibt einen anderen Weg in ES6, mit Array.from , das 2 Argumente akzeptiert, der erste ist ein arrayLike (in diesem Fall ein Objekt mit der Eigenschaft length), und der zweite ist eine Mapping-Funktion (in diesem Fall bilden wir die Artikel zu seinem Index)

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

dies ist kürzer und kann für andere Sequenzen wie das Generieren gerader Zahlen verwendet werden

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

Dies hat auch eine bessere Leistung als die meisten anderen Möglichkeiten, da es nur einmal durch das Array durchläuft. Überprüfen Sie das Snippit auf 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")

16
Gaafar

Verwendung neuer Array-Methoden und =>-Funktionssyntax vom ES6-Standard (nur Firefox zum Zeitpunkt des Schreibens).

Durch das Füllen von Löchern mit undefined

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

Array.from verwandelt "Löcher" in undefined, damit Array.map wie erwartet funktioniert:

Array.from(Array(5)).map((_, i) => i + 1)
13
szymzet
for(var i,a=[i=0];i<10;a[i++]=i);

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

12
SammieFox

Versuche dies: 

var foo = [1, 2, 3, 4, 5];

Wenn Sie CoffeeScript verwenden, können Sie einen Bereich erstellen, indem Sie Folgendes tun:

var foo = [1..5]; 

Wenn Sie Vanilla JavaScript verwenden, müssen Sie andernfalls eine Schleife verwenden, wenn Sie ein Array mit einer variablen Länge initialisieren möchten.

10
Zach Rattner

Etwas einfacher als die Stringvariante:

// create range by N
Array(N).join(0).split(0);

// create a range starting with 0 as the value
Array(7).join(0).split(0).map((v, i) => i + 1) // [1, 2, 3, 4, 5, 6, 7]

Update (1/4/2018): Aktualisiert, um die genaue OP-Frage zu beantworten. Danke, @lessless, dass du das gerufen hast!

9
Matt Lo

Es scheint, dass die einzige Variante, die derzeit nicht in dieser ziemlich vollständigen Liste von Antworten enthalten ist, eine mit einem Generator ist; um das zu beheben:

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

was kann so verwendet werden:

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

Das Schöne daran ist, dass Sie nicht nur inkrementieren müssen ... Um sich von der Antwort @ igor-shubin inspirieren zu lassen, können Sie sehr leicht eine Reihe von Randomen erstellen:

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

Und eher als etwas langwierig betrieblich teuer 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})()]
8
Robin

Die folgende Funktion gibt ein mit Zahlen gefülltes Array zurück:

var createArrayOfNumbers = function (n) {
    return Array.apply(null, new Array(n)).map(function (empty, index) {
        return index;
    });
};

Beachten Sie, dass ein Array, das mit dem Array-Konstruktor erstellt wurde, aus Löchern besteht. Es kann also nicht mit Array-Funktionen wie Map durchlaufen werden. Verwenden Sie daher die Array.apply-Funktion.

7
Ghasem Kiani

Nur eine weitere ES6 Version.

Verwenden Sie das optionale Argument Array.from second:

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);

7
zurfyx

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

Gibt [0, 1, 2] zurück. Sehr ähnlich zu Igor Shubins exzellente Antwort , jedoch mit etwas weniger Trickserei (und einem Charakter länger).

Erläuterung:

  • Array(3) // [undefined × 3] Erzeugt ein Array 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] macht das Array iterierbar. Anmerkung: Nullen sind häufiger als das erste Argument von apply, aber 0 sind kürzer.
  • Object.keys(Array.apply(0,Array(3))) // ['0', '1', '2'] ruft dann die Schlüssel des Arrays ab (funktioniert, weil Arrays der Typ des Arrays ist, ein Objekt mit Indizes für Schlüssel.
  • Object.keys(Array.apply(0,Array(3))).map(Number) // [0, 1, 2] und über die Tasten ordnen, Strings in Zahlen umwandeln.
7
mLuby

Verwendung von ES6

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

Iterable Version mit einer Generator - Funktion, die Number.prototype nicht ändert.

function sequence(max, step = 1) {
  return {
    [Symbol.iterator]: function* () {
      for (let i = 1; i <= max; i += step) yield i
    }
  }
}

console.log([...sequence(10)])

6
yckart
Array(8).fill(0).map(Number.call, Number)

Igors Number.call-Trick stehlen, aber mit fill() etwas verkürzen. Funktioniert nur mit ES6 und höher.

6
Tom

Improvisieren auf dem Vorstehenden:

var range = function (n) {
  return Array(n).join().split(',').map(function(e, i) { return i; });
}  

man kann folgende Optionen bekommen:

1) Array.init bis Wert v

var arrayInitTo = function (n,v) {
  return Array(n).join().split(',').map(function() { return v; });
}; 

2) einen umgekehrten Bereich erhalten:

var rangeRev = function (n) {
  return Array(n).join().split(',').map(function() { return n--; });
};
6
laborhm

Ich suchte nach einer funktionalen Lösung und endete mit:

function numbers(min, max) {
  return Array(max-min+2).join().split(',').map(function(e, i) { return min+i; });
}

console.log(numbers(1, 9));

Hinweis: join().split(',') wandelt das spärliche Array in ein zusammenhängendes Array um.

6
Bruno Jouhier

Ich habe keine Lösung gefunden, die auf rekursiven Funktionen basiert (und selbst nie rekursive Funktionen geschrieben hat). Hier ist mein Versuch.

Beachten Sie, dass array.Push (etwas) die neue Länge des Arrays zurückgibt: 

(a=[]).Push(a.Push(a.Push(0))) //  a = [0, 1, 2]

Und mit einer rekursiven Funktion:

var a = (function f(s,e,a,n){return ((n?n:n=s)>e)?a:f(s,e,a?a:a=[],a.Push(n)+s)})(start,end) // e.g., start = 1, end = 5

EDIT: zwei andere Lösungen

var a = Object.keys(new Int8Array(6)).map(Number).slice(1)

und

var a = []
var i=setInterval(function(){a.length===5?clearInterval(i):a.Push(a.length+1)}) 
6
radsoc

Sie können einen Funktionsgenerator oder einen Funktionsausdruck verwenden. Hier ist [ https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/function _ ​​] And eine Referenz auf den Funktionsgenerator-Link zu [ https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function].

let a = 1, b = 10;

function* range(a, b) { for (var i = a; i <= b; ++i) yield i; }

Array.from(range(a, b));// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

[...range(a, b)]// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

6

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 gaben. 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 das, weil ich es einfach und leichter finde.

5
T.M

Ich habe diesen alten Thread gefunden, weil ich mich selbst darüber gewundert habe, aber ich denke, dass keine der Antworten hier einfacher war als Ihr ursprüngliches Beispiel, als Kokodoko kommentierte, haha!

Ich habe diese Methode selbst verwendet:

var foo = [];
while (foo.length < N)
    foo.Push( foo.length + 1 );

Das ist zumindest etwas schneller zu tippen als eine reguläre for-Schleife und hoffentlich nicht fehleranfällig (obwohl dies rechnerisch teurer sein könnte).

Kann sogar so etwas tun:

var foo= [];
while (foo.length < N)
    foo.Push( foo.length%4 + 1 );

um das Array mehrmals mit 1-4 zu füllen. Oder verwenden Sie diese Methode, um das Array mit einem einzelnen Element zu füllen. In diesem Fall könnte es jedoch schneller sein, Array(N).fill(x) zu verwenden.

4
Mythril

Versuchen Sie, dem Prototyp von Number einen Iterator hinzuzufügen.

Number.prototype[Symbol.iterator] = function *(){
  let i = 0;
  while(i < this) yield i++;
  return;
}

Nun, da Zahlen iterierbar sind, übergeben Sie einfach eine Nummer an Array.from

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

oder anderswo ist ein iterierbares Element wie für ... von Schleifen .

for(const number of 10) console.log(number);//logs 0 through 9 sequentially

Es ist etwas kompliziert, aber auch cool. 

3
John Henry

mit ES6 können Sie:

// `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)
3
marko424

Lass uns meine teilen: p

var i = 10; 
Math.pow(2, i).toString(2).split('').map((i,j) => j)
3
nfroidure

ES5-Version, ineffizient, aber vielleicht die kürzeste, die ein Ausdruck ist, nicht irgendeine Anweisung , in der eine Variable mit zB gefüllt ist. eine for-Schleife: 

(Array(N)+'').split(',').map(function(d,i){return i})
2
Robert Monfera

All dies ist zu kompliziert. Mach einfach:

function count(num) {
  var arr = [];
  var i = 0;

  while (num--) {
    arr.Push(i++);
  }

  return arr;
}

console.log(count(9))
//=> [ 0, 1, 2, 3, 4, 5, 6, 7, 8 ]

Oder einen Bereich von a bis b ausführen

function range(a, b) {
  var arr = [];

  while (a < b + 1) {
    arr.Push(a++);
  }

  return arr;
}

console.log(range(4, 9))
//=> [ 4, 5, 6, 7, 8, 9 ]
2
jonschlinkert
function arrGen(n) {
  var a = Array(n)
  while (n--) a[n] = n
  return a
}
// arrGen(10) => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
2
Ken Berkeley

// A solution where you do not allocate a N sized array (ES6, with some flow annotation):
function* zeroToN(N /* : number */)/* : Generator<number, void, empty> */ {
  for (let n = 0; n <= N; n += 1) yield n;
}

// With this generation, you can have your array
console.log([...zeroToN(10-1)])

// but let's define a helper iterator function
function mapIterator(iterator, mapping) {
  const arr = [];
  for (let result = iterator.next(); !result.done; result = iterator.next()) {
    arr.Push(mapping(result.value));
  }
  return arr;
}

// now you have a map function, without allocating that 0...N-1 array

console.log(mapIterator(zeroToN(10-1), n => n*n));

2
Fred

Die Frage war für Alternativen zu dieser Technik, aber ich wollte die schneller Methode teilen. Es ist fast identisch mit dem Code in der Frage, aber es wird Speicher zugewiesen, anstatt Push zu verwenden:

function range(n) {
    let a = Array(n);
    for (let i = 0; i < n; a[i++] = i);
    return a;
}
2
Corey Alix

Nur zum Spaß wollte ich von Ian Henrys Antwort abbauen.

Natürlich gibt Ihnen var array = new Array(N); ein Array mit der Größe N, aber die Schlüssel und Werte sind identisch ..... Um das Array auf die Größe M zu reduzieren, verwenden Sie array.length = M.....

function range()
{
    // This function takes optional arguments:
    // start, end, increment
    //    start may be larger or smaller than end
    // Example:  range(null, null, 2);

    var array = []; // Create empty array

      // Get arguments or set default values:
    var start = (arguments[0] ? arguments[0] : 0);
    var end   = (arguments[1] ? arguments[1] : 9);
      // If start == end return array of size 1
    if (start == end) { array.Push(start); return array; }
    var inc   = (arguments[2] ? Math.abs(arguments[2]) : 1);

    inc *= (start > end ? -1 : 1); // Figure out which direction to increment.

      // Loop ending condition depends on relative sizes of start and end
    for (var i = start; (start < end ? i <= end : i >= end) ; i += inc)
        array.Push(i);

    return array;
}

var foo = range(1, -100, 8.5)

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

Ausgabe der oben genannten:

1 ist Artikel: 1 von 12
-7,5 ist Artikel: 2 von 12
-16 ist Artikel: 3 von 12
-24.5 ist Artikel: 4 von 12
-33 ist Artikel: 5 von 12
-41.5 ist Artikel: 6 von 12
-50 is item: 7 of 12
-58.5 ist Artikel: 8 von 12
-67 ist Artikel: 9 von 12
-75.5 ist Artikel: 10 von 12
-84 ist ein Artikel: 11 von 12
-92.5 ist Artikel: 12 von 12 

jsFiddle-Beispiel

Diese Funktion verwendet das automatisch generierte arguments - Array.

Die Funktion erstellt ein Array mit Werten, die bei start beginnen und bei end mit Inkrementen der Größe increment beginnen, wobei

range(start, end, increment);

Jeder Wert hat einen Standardwert und das Vorzeichen des Inkrements spielt keine Rolle, da die Richtung der Inkrementierung von der relativen Größe von Anfang und Ende abhängt.

2
Peter Ajtai

'_'.repeat(5).split('').map((_, i) => i + 1) ergibt [1, 2, 3, 4, 5]

1
webjay

Hier ist die Zusammenfassung (in der Konsole ausgeführt):

// setup:
var n = 10000000;
function* rangeIter(a, b) {
    for (let i = a; i <= b; ++i) yield i;
}
function range(n) { 
    let a = []
    for (; n--; a[n] = n);
    return a;
}
function sequence(max, step = 1) {
    return {
        [Symbol.iterator]: function* () {
            for (let i = 1; i <= max; i += step) yield i
        }
    }
}

var t0, t1, arr;
// tests
t0 = performance.now();
arr = Array.from({ length: n }, (a, i) => 1)
t1 = performance.now();
console.log("Array.from({ length: n }, (a, i) => 1) Took " + (t1 - t0) + " milliseconds.");

t0 = performance.now();
arr = range(n);
t1 = performance.now();
console.log("range(n) Took " + (t1 - t0) + " milliseconds.");

t0 = performance.now();
arr = Array.from(rangeIter(0, n));
t1 = performance.now();
console.log("Array.from(rangeIter(0, n)) Took " + (t1 - t0) + " milliseconds.");

t0 = performance.now();
arr = [...rangeIter(0, n)];
t1 = performance.now();
console.log("[...rangeIter(0, n)] Took " + (t1 - t0) + " milliseconds.");

t0 = performance.now();
arr = Array.from(sequence(n));
t1 = performance.now();
console.log("Array.from(sequence(n)) Took " + (t1 - t0) + " milliseconds.");

t0 = performance.now();
arr = [...sequence(n)];
t1 = performance.now();
console.log("[...sequence(n)] Took " + (t1 - t0) + " milliseconds.");

t0 = performance.now();
arr = Array(n).fill(0).map(Number.call, Number);
t1 = performance.now();
console.log("Array(n).fill(0).map(Number.call, Number) Took " + (t1 - t0) + " milliseconds.");

t0 = performance.now();
arr = Array.from(Array(n).keys());
t1 = performance.now();
console.log("Array.from(Array(n).keys()) Took " + (t1 - t0) + " milliseconds.");

t0 = performance.now();
arr = [...Array(n).keys()];
t1 = performance.now();
console.log("[...Array(n).keys()] Took " + (t1 - t0) + " milliseconds.");

Das schnellste ist Array (n) .fill (0) .map (Number.call, Number), 2. ist [... Array (n) .keys ()]

Aber '... rangeIter'-Weg ist ziemlich praktisch (kann inliniert werden), schnell und leistungsfähiger

1
SalientBrain

ES6-Lösung mit Rekursion. Anders als alle anderen Lösungen

const range = (n, A = []) => (n === 1) ? [n, ...A] : range(n - 1, [n, ...A]);


console.log(range(5));
1
Sumer

Die wenigsten Codes, die ich produzieren könnte:

for(foo=[x=100]; x; foo[x-1]=x--);
console.log(foo);
1
Coisox

array mit n Zufallszahlen zwischen min, max (nicht eindeutig)

function callItWhatYouWant(n, min, max) {
    return Array.apply(null, {length: n}).map(Function.call, function(){return Math.floor(Math.random()*(max-min+1)+min)})
}
1
Nour Chawich

Nun, einfache, aber wichtige Frage. Functional JS fehlt definitiv eine generische Entfaltungsmethode unter dem Array-Objekt, da möglicherweise ein Array numerischer Elemente erstellt werden muss. Dies ist nicht nur ein einfacher [1,2,3,...,111], sondern eine aus einer Funktion resultierende Serie. Sie könnte wie x => x*2 anstelle von x => x aussehen.

Um diesen Job auszuführen, müssen wir uns derzeit auf die Array.prototype.map()-Methode verlassen. Um Array.prototype.map() verwenden zu können, müssen Sie jedoch die Größe des Arrays im Voraus kennen. Nun noch ... wenn wir die Größe nicht kennen, können wir Array.prototype.reduce() verwenden, aber Array.prototype.reduce() ist dazu gedacht, das Falzen von Rechten zu reduzieren.

Daher brauchen wir offensichtlich ein Array.unfold()-Tool in funktionalem JS. Dies ist etwas, das wir uns einfach so umsetzen können;

Array.unfold = function(p,f,t,s){
  var res = [],
   runner = v =>  p(v,res.length-1,res) ? [] : (res.Push(f(v)),runner(t(v)), res);
  return runner(s);
};

Arrays.unfold(p,f,t,v) nimmt 4 Argumente an.

  • p Dies ist eine Funktion, die definiert, wo angehalten werden soll. Die Funktion p nimmt 3 Argumente an, wie dies bei vielen Array-Funktionen der Fall ist. Der Wert, der Index und das aktuell resultierende Array. Es soll einen booleschen Wert zurückgeben. Wenn eine true zurückgegeben wird, wird die rekursive Iteration beendet.
  • f Dies ist eine Funktion, um den Funktionswert der nächsten Elemente zurückzugeben.
  • t Dies ist eine Funktion, um das nächste Argument zurückzugeben, das in der nächsten Runde an f übergeben wird.
  • s Ist der Startwert, der zur Berechnung des bequemen Sitzes von Index 0 durch f verwendet wird.

Wenn wir also beabsichtigen, ein Array zu erstellen, das mit einer Serie wie 1,4,9,16,25 ... n ^ 2 gefüllt ist, können wir dies einfach tun.

Array.unfold = function(p,f,t,s){
  var res = [],
   runner = v =>  p(v,res.length-1,res) ? [] : (res.Push(f(v)),runner(t(v)), res);
  return runner(s);
};

var myArr = Array.unfold((_,i) => i >= 9, x => Math.pow(x,2), x => x+1, 1);
console.log(myArr);

1
Redu

Es gibt eine kleine Funktion, die es erlaubt, Konstruktionen wie [1, 2] .range (3, 4) -> [1, 2, 3, 4] zu verwenden, es funktioniert auch mit negativen Parametern. Genießen.

Array.prototype.range = function(from, to)
{
   var range = (!to)? from : Math.abs(to - from) + 1, increase = from < to;
   var tmp = Array.apply(this, {"length": range}).map(function()
      {
         return (increase)?from++ : from--;
      }, Number);

   return this.concat(tmp);
};
0

für mich ist das ein nützlicherer Nutzen:

/**
 * create an array filled with integer numbers from base to length
 * @param {number} from
 * @param {number} to
 * @param {number} increment
 * @param {Array} exclude
 * @return {Array}
 */
export const count = (from = 0, to = 1, increment = 1, exclude = []) => {
  const array = [];
  for (let i = from; i <= to; i += increment) !exclude.includes(i) && array.Push(i);
  return array;
};
0

Azle hat eine Utility-Funktion namens create_array, die Ihnen eine Reihe von Optionen gibt: 

Erstellen Sie ein Array von 0 bis 5:

az.create_array(0, 5)

[0, 1, 2, 3, 4, 5

Erstellen Sie ein Array von 1 bis 5:

az.create_array(1, 5)

[1, 2, 3, 4, 5]

Erstellen Sie ein Array von 5 Arrays

az.create_array(1, 5, ['apples','carrots','oranges'])

[ ["Äpfel", "Karotten", "Orangen"], ["Äpfel", "Karotten", "Orangen"], ["Äpfel", "Karotten", "Orangen" ], ["Äpfel", "Karotten", "Orangen"], ["Äpfel", "Karotten", "Orangen"] ]

Erstellen Sie ein Array von 5 Objekten:

az.create_array(1, 5, {"color" : "orangered"})

[{color: "orangered"}, {color: "orangered"}, {color: "orangered"}, {color: "orangered"}, {color: "orangered "}]

Erstellen Sie ein Array mit 6 Zufallszahlen:

az.create_array(0,5,'random') // default draws from 10

[9, 5, 4, 6, 9, 7]

Erstellen Sie ein Array mit 6 Zufallszahlen aus 1000:

az.create_array(0,5,'random', 1000)

[180, 372, 678, 142, 314, 438]

Hier ist die GEIGE

0
Cybernetic

Da es viele gute Antworten gibt, kann dies auch eine Option sein. Sie können auch eine Funktion mit der folgenden erstellen, die für jede Kombination von Zahlen funktioniert

const start = 10;
const end = 30;    
const difference = Math.abs(start-end);
const rangeArray = new Array(difference + 1).fill(undefined).map((val, key) => {
    return start > end ? start - key : start + key;
})
0
emcee22

Für kleine Reichweiten ist eine Scheibe Nizza. N ist nur zur Laufzeit bekannt, also:

[0, 1, 2, 3, 4, 5].slice(0, N+1)
0
dansalmo

Array.prototype.fill ()

a = Object.keys( [].fill.call({length:7}, '' ) ).map(Number)
a.pop();
console.debug(a)

[0, 1, 2, 3, 4, 5, 6]

0
bjhamltn