W ES6 przy użyciu metod Array from()i keys().

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

Krótsza wersja przy użyciu operatora spreadu.

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

Zacznij od 1 przekazując funkcję map do tablicy from () , z obiektem o właściwości length:

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

Możesz to zrobić:

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

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

Lub z losowymi wartościami:

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

Wynik: [0.7082694901619107, 0.9572225909214467, 0.8586748542729765, 0.8653848143294454, 0.008339877473190427, 0.9911756622605026, 0.8133423360995948, 0.8377588465809822, 0.5577575915958732, 0.16363654541783035]

Wyjaśnienie

Po pierwsze, zauważ, że {[4] } jest równoważne Number(N), które po prostu zwraca N. Wykorzystamy to później.

Array.apply(null, [undefined, undefined, undefined]) jest odpowiednikiem Array(undefined, undefined, undefined), który tworzy trzyelementową tablicę i przypisuje undefined do każdego elementu.

Jak można to uogólnić do N elementów? Zastanów się jak Array() działa, co idzie mniej więcej tak:

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

Od ECMAScript 5, Function.prototype.apply(thisArg, argsArray) akceptuje również obiekt typu tablica typu kaczki jako drugi parametr. Jeśli wywołamy Array.apply(null, { length: N }), to wykona

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

Teraz mamy N - tablica elementów, z każdym elementem ustawionym na undefined. When we call .map(callback, thisArg) na nim każdy element zostanie ustawiony na wynik callback.call(thisArg, element, index, array). Dlatego [undefined, undefined, …, undefined].map(Number.call, Number) odwzorowywałby każdy element na (Number.call).call(Number, undefined, index, array), co jest tym samym co Number.call(undefined, index, array), które, jak zauważyliśmy wcześniej, ocenia na index. Uzupełnia tablicę, której elementy są takie same jak ich indeks.

Po co zadawać sobie trud Array.apply(null, {length: N}) zamiast po prostu Array(N)? Wszakże oba wyrażenia spowodowałyby an N -element tablica niezdefiniowanych elementów. Różnica polega na tym, że w pierwszym wyrażeniu każdy element jest jawnie ustawiony na undefined, podczas gdy w drugim, każdy element nigdy nie został ustawiony. Zgodnie z dokumentacją .map():

callback jest wywoływane tylko dla indeksów tablicy, które mają przypisane wartości; nie jest wywoływane dla indeksów, które zostały usunięte lub które nigdy nie zostały przypisane wartości.

Dlatego, Array(N) jest niewystarczająca; Array(N).map(Number.call, Number) wynikałoby z niezaliczonej tablicy długości N .

Zgodność

Multiple ways using ES6

Używając operatora spread (...) i metody keys

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

Wypełnij / Mapa

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

Array.od

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

Array.from and { length: N } hack

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

Uwaga o formie uogólnionej

Wszystkie powyższe formularze mogą wytworzyć tablice zainicjalizowane do prawie dowolnych pożądanych wartości poprzez zmianę i+1 na wymagane wyrażenie (np. i*2, -i, 1+i*2, i%2 i itp.). Jeśli wyrażenie może być wyrażone przez jakąś funkcję f wtedy pierwsza forma staje się po prostu

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

Przykłady:

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

Ponieważ tablica jest inicjalizowana undefined na każdej pozycji, Wartość v będzie undefined

Przykład prezentujący wszystkie formy

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)

Bardziej ogólny przykład z niestandardową funkcją inicjującą f tj.

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

Lub nawet prościej

[ ...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)

Tablice z natury zarządzają ich długościami. W miarę ich przechodzenia, ich indeksy mogą być przechowywane w pamięci i odwoływane w tym momencie. Jeśli trzeba znać indeks losowy, można użyć metody indexOf.

To powiedziawszy, dla Twoich potrzeb możesz po prostu chcieć zadeklarować tablicę o określonej wielkości:

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

Spread

Korzystanie z operatora spread (...) i metody keys, umożliwia utworzenie tymczasowej tablicy o rozmiarze n do tworzy indeksy, a następnie nową tablicę, którą można przypisać do zmiennej:

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

Wypełnij / Mapa

Możesz najpierw utworzyć rozmiar tablicy, którą potrzebujesz, wypełnić ją undefined, a następnie utworzyć nową tablicę za pomocą map, która ustawia każdy element w indeksie.

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

Array.od

Powinno to być inicjalizacją do długości rozmiaru N i wypełnieniem tablicy w jednym przejściu.

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

Zamiast komentarzy i zamieszania, jeśli naprawdę chciałem uchwycić wartości z 1..N w powyższych przykładach istnieje kilka opcji:

1. jeśli indeks jest dostępny, możesz go po prostu zwiększyć o jeden (np. ++i).

2. W przypadkach, gdy indeks nie jest używany-i być może bardziej efektywnym sposobem-jest utworzenie tablicy, ale niech N reprezentuje N+1, a następnie przesunięcie z przodu.

   Więc jeśli pragniesz 100 liczb:

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

W ES6 możesz zrobić:

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

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

Edytuj: Zmieniono Array(45) na Array(N) odkąd zaktualizowałeś pytanie.

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

Użyj bardzo popularnego podkreślenie _.metoda zasięgu

// _.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;
}

Następnie wywołany przez

var foo = range(1, 5);

Nie ma wbudowanego sposobu, aby to zrobić w Javascript, ale jest to doskonale poprawna funkcja użytkowa do utworzenia, jeśli chcesz zrobić to więcej niż raz.

Edit: moim zdaniem, poniżej znajduje się lepsza funkcja range. Może dlatego, że jestem stronniczy LINQ, ale myślę, że jest bardziej przydatny w większej liczbie przypadków. Przebieg może się różnić.

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

Najszybszym sposobem wypełnienia Array W v8 jest:

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

Wynik będzie: [0, 1, 2, 3, 4]

To pytanie ma wiele skomplikowanych odpowiedzi, ale proste jednolinijkowe:

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

Ponadto, chociaż powyższe jest krótkie (i zgrabne) do napisania, myślę, że poniższe jest nieco szybsze (dla maksymalnej długości:

127, Int8,

255, Uint8,

32,767, Int16,

65,535, Uint16,

2,147,483,647, Int32,

(na podstawie max wartości całkowitych ), również tutaj jest więcej na wpisane Tablice):

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

Chociaż to rozwiązanie również nie jest tak idealne, ponieważ tworzy dwie tablice i używa dodatkowej zmiennej deklaracji " $ " (Nie wiem, jak to obejść za pomocą tej metody). Myślę, że następujące rozwiązanie jest absolutnym najszybszym możliwym sposobem, aby to zrobić:

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

W dowolnym momencie po złożeniu tego polecenia, możesz w prosty sposób użyć zmiennej "arr" w bieżącym zakresie;

Jeśli chcesz zrobić z niego prostą funkcję (z pewną podstawową weryfikacją):

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

Więc, z powyższą funkcją, powyższa super-wolna "prosta jednowierszowa" staje się super-szybka, nawet krótsza:

range(1,14000);

Możesz użyć tego:

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

Na przykład

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

Utworzy następującą tablicę:

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

Używanie operatora spreadu ES2015 / ES6

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

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

Jeśli przypadkiem używasz d3.js w Twojej aplikacji tak jak ja, D3 zapewnia funkcję pomocnika, która robi to za Ciebie.

Aby uzyskać tablicę od 0 do 4, jest to tak proste jak:

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

I aby uzyskać tablicę od 1 do 5, tak jak prosiłeś:

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

Sprawdź ten samouczek Aby uzyskać więcej informacji.

Jest to prawdopodobnie najszybszy sposób na wygenerowanie tablicy liczb

Najkrótsza

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

Inline

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

Jeśli chcesz zacząć od 1

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]

Chcesz funkcji?

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]

Dlaczego?

1. while jest najszybszą pętlą

2. Bezpośrednie ustawienie jest szybsze niż push

3. [] jest szybszy niż new Array(10)

4. Jest krótki... spójrz na pierwszy kod. Zobacz też inne Funkcje tutaj.

If you like can ' t live without for

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

Lub

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

Jeśli używasz lodash, możesz użyć _.zakres :

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

Tworzy tablicę liczb (dodatni i/lub ujemny) włącznie z zakończeniem. Krok -1 jest używany, jeśli podano ujemny początek bez końca i kroku. Jeśli end nie jest określony, jest ustawiony na start z start następnie ustawić na 0.

Przykłady:

_.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);
// ➜ []

Nowy sposób wypełnienia Array to:

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

Wynik będzie: [0, 1, 2, 3, 4]

Z ES6 możesz zrobić:

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

końcowy raport podsumowujący .. Drrruummm Rolll -

To jest najkrótszy kod aby wygenerować tablicę o rozmiarze N (tutaj 10) bez użycia ES6 . wersja Cocco powyżej jest bliska, ale nie Najkrótsza.

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

Ale niekwestionowanym zwycięzcą tego kodu jestNiko Ruotsalainen . Używanie konstruktora tablicy i spreadu ES6 operator . (Większość składni ES6 jest poprawnym maszynopisem, ale nie jest. Więc bądź rozsądny podczas korzystania z niego)

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

Jest inny sposób w ES6, używając tablicy .z, która pobiera 2 argumenty, pierwszy jest arrayLike( w tym przypadku obiekt z właściwością length), a drugi jest funkcją mapowania (w tym przypadku mapujemy element do jego indeksu)

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

Jest krótszy i może być używany do innych sekwencji, takich jak generowanie liczb parzystych

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

Ma również lepszą wydajność niż większość innych sposobów, ponieważ pętli tylko raz przez tablicę. Sprawdź fragment dla niektórych porównania

// 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")

Przy użyciu nowych metod tablicowych i składni funkcji => ze standardu ES6(tylko Firefox w momencie pisania).

Przez wypełnienie otworów za pomocą undefined:

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

Array.from zamienia "dziury" w undefined więc Array.map działa zgodnie z oczekiwaniami:

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

W ES6:

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

Lub jeszcze lepiej (bez dodatkowej zmiennej _ i bez dodatkowego wywołania slice):

Array.from({length:1000}, Number.call, i => i + 1)

Lub dla nieco szybszych wyników, możesz użyć Uint8Array, jeśli Twoja lista jest krótsza niż 256 wyników (lub możesz użyć innych list Uint w zależności od tego, jak krótka jest lista, jak Uint16 dla maksymalnej liczby 65535 lub Uint32 dla maksymalnej liczby 4294967295 itd. oficjalnie, te typowane tablice zostały dodane tylko w ES6 chociaż ). Na przykład:

Uint8Array.from({length:10}, Number.call, i => i + 1)

ES5:

Array.apply(0, {length: 1000}).map(function(){return arguments[1]+1});

Alternatywnie, w ES5, dla funkcji map (jak drugi parametr do funkcji Array.from w ES6 powyżej), możesz użyć Number.call

Array.apply(0,{length:1000}).map(Number.call,Number).slice(1)

Lub, jeśli jesteś przeciw .slice tutaj również, możesz zrobić odpowiednik ES5 powyższego (od ES6), jak:

Array.apply(0,{length:1000}).map(Number.call, Function("i","return i+1"))

Https://stackoverflow.com/a/49577331/8784402

Z Deltą

Dla javascript

[...Array(N)].map((v, i) => from + i * step);

Przykłady i inne alternatywy

Array.from(Array(10).keys()).map(i => 4 + i * 2);
//=> [4, 6, 8, 10, 12, 14, 16, 18, 20, 22]

[...Array(10).keys()].map(i => 4 + i * -2);
//=> [4, 2, 0, -2, -4, -6, -8, -10, -12, -14]

Array(10).fill(0).map((v, i) => 4 + i * 2);
//=> [4, 6, 8, 10, 12, 14, 16, 18, 20, 22]

Array(10).fill().map((v, i) => 4 + i * -2);
//=> [4, 2, 0, -2, -4, -6, -8, -10, -12, -14]

[...Array(10)].map((v, i) => 4 + i * 2);
//=> [4, 6, 8, 10, 12, 14, 16, 18, 20, 22]

const range = (from, to, step) =>
  [...Array(Math.floor((to - from) / step) + 1)].map((_, i) => from + i * step);

range(0, 9, 2);
//=> [0, 2, 4, 6, 8]

// can also assign range function as static method in Array class (but not recommended )
Array.range = (from, to, step) =>
  [...Array(Math.floor((to - from) / step) + 1)].map((_, i) => from + i * step);

Array.range(2, 10, 2);
//=> [2, 4, 6, 8, 10]

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

Array.range(2, 10, -1);
//=> []

Array.range(3, 0, -1);
//=> [3, 2, 1, 0]

class Range {
  constructor(total = 0, step = 1, from = 0) {
    this[Symbol.iterator] = function* () {
      for (let i = 0; i < total; yield from + i++ * step) {}
    };
  }
}

[...new Range(5)]; // Five Elements
//=> [0, 1, 2, 3, 4]
[...new Range(5, 2)]; // Five Elements With Step 2
//=> [0, 2, 4, 6, 8]
[...new Range(5, -2, 10)]; // Five Elements With Step -2 From 10
//=>[10, 8, 6, 4, 2]
[...new Range(5, -2, -10)]; // Five Elements With Step -2 From -10
//=> [-10, -12, -14, -16, -18]

// Also works with for..of loop
for (i of new Range(5, -2, 10)) console.log(i);
// 10 8 6 4 2

const Range = function* (total = 0, step = 1, from = 0) {
  for (let i = 0; i < total; yield from + i++ * step) {}
};

Array.from(Range(5, -2, -10));
//=> [-10, -12, -14, -16, -18]

[...Range(5, -2, -10)]; // Five Elements With Step -2 From -10
//=> [-10, -12, -14, -16, -18]

// Also works with for..of loop
for (i of Range(5, -2, 10)) console.log(i);
// 10 8 6 4 2

// Lazy loaded way
const number0toInf = Range(Infinity);
number0toInf.next().value;
//=> 0
number0toInf.next().value;
//=> 1
// ...

Od-Do ze stopniami / delta

class Range2 {
  constructor(to = 0, step = 1, from = 0) {
    this[Symbol.iterator] = function* () {
      let i = 0,
        length = Math.floor((to - from) / step) + 1;
      while (i < length) yield from + i++ * step;
    };
  }
}
[...new Range2(5)]; // First 5 Whole Numbers
//=> [0, 1, 2, 3, 4, 5]

[...new Range2(5, 2)]; // From 0 to 5 with step 2
//=> [0, 2, 4]

[...new Range2(5, -2, 10)]; // From 10 to 5 with step -2
//=> [10, 8, 6]

const Range2 = function* (to = 0, step = 1, from = 0) {
  let i = 0,
    length = Math.floor((to - from) / step) + 1;
  while (i < length) yield from + i++ * step;
};

[...Range2(5, -2, 10)]; // From 10 to 5 with step -2
//=> [10, 8, 6]

let even4to10 = Range2(10, 2, 4);
even4to10.next().value;
//=> 4
even4to10.next().value;
//=> 6
even4to10.next().value;
//=> 8
even4to10.next().value;
//=> 10
even4to10.next().value;
//=> undefined

Do Maszynopisu

class _Array<T> extends Array<T> {
  static range(from: number, to: number, step: number): number[] {
    return Array.from(Array(Math.floor((to - from) / step) + 1)).map(
      (v, k) => from + k * step
    );
  }
}
_Array.range(0, 9, 1);

Array(...Array(9)).map((_, i) => i);

console.log(Array(...Array(9)).map((_, i) => i))

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

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

Wydaje się, że jedynym smakiem, który obecnie nie znajduje się na tej dość kompletnej liście odpowiedzi, jest ten z generatorem; więc aby zaradzić, że: {]}

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

Które można wykorzystać w ten sposób:

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

Fajną rzeczą w tym jest to, że nie musisz tylko zwiększać... Aby czerpać inspirację z odpowiedzi udzielonej przez @ igor-shubin, można bardzo łatwo stworzyć tablicę randomów:

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

I zamiast czegoś długiego kosztownego jak:

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

Możesz zamiast do:

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

Możesz użyć Array fill i map z Es6; tak jak kilka osób zasugerowało w odpowiedziach na to pytanie. Poniżej kilka przykładów:

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]

Wolę to, ponieważ uważam to za proste i łatwiejsze.

Używanie ES6

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

Just another ES6 version.

Poprzez wykorzystanie Array.from drugi argument opcjonalny:

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

Możemy zbudować numerowaną tablicę z pustych pozycji Array(10):

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

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

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

Kradzież Igorów Number.call sztuczka, ale użycie fill() do lekkiego skrócenia. Działa tylko z ES6 i nowszymi.

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

Zwraca [0, 1, 2]. Bardzo podobna do doskonała odpowiedź Igora Szubina , ale z nieco mniejszą ilością sztuczek (i jedną postacią dłuższą).

Wyjaśnienie:

• Array(3) // [undefined × 3] Wygeneruj tablicę długości n = 3. Niestety ta tablica jest dla nas prawie bezużyteczna, więc musimy ...
• Array.apply(0,Array(3)) // [undefined, undefined, undefined] uczyń tablicę iterowalną. Uwaga: null jest bardziej powszechne jako pierwszy arg apply, ale 0 jest krótsze.
• Object.keys(Array.apply(0,Array(3))) // ['0', '1', '2'] następnie pobierz klucze tablicy (działa, ponieważ tablice są tablica typeof jest obiektem z indeksami dla kluczy.
• Object.keys(Array.apply(0,Array(3))).map(Number) // [0, 1, 2] i mapować nad kluczami, konwertując ciągi znaków na liczby.