1에서 N까지의 JavaScript 배열을 만드는 아래의 대안을 찾고 있습니다. 여기서 N은 런타임에만 알려져 있습니다.

var foo = [];

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

나에게 루프없이 이것을하는 방법이 있어야한다고 생각합니다.

내가 당신이 무엇을 얻는다면, 1..n당신은 나중에 반복 할 수 있는 숫자 배열을 원합니다 .

이것이 당신이 필요한 전부라면, 대신 할 수 있습니까?

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

그런 다음 사용하고 싶을 때 ... (예를 들어 최적화되지 않은)

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

예를 들어 배열에 아무것도 저장할 필요가 없다면 반복 할 수있는 올바른 길이의 컨테이너가 필요합니다 ... 더 쉬울 수 있습니다.

http://jsfiddle.net/3kcvm/ 에서 실제로 확인하십시오.

ES6에서는 Array from () 및 keys () 메소드를 사용합니다.

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

스프레드 연산자를 사용하는 더 짧은 버전 .

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

그렇게 할 수 있습니다 :

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

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

또는 임의의 값으로 :

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

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

설명

먼저,는를 반환하는 Number.call(undefined, N)것과 같습니다 . 우리는 나중에 그 사실을 사용할 것입니다.Number(N)N

Array.apply(null, [undefined, undefined, undefined])는 Array(undefined, undefined, undefined)3 요소 배열을 생성하고 undefined각 요소에 할당하는와 같습니다 .

이것을 N 요소로 일반화 할 수 있습니까? Array()작동 방식을 고려하십시오 .

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

ECMAScript를 5부터 , Function.prototype.apply(thisArg, argsArray)또한 두 번째 매개 변수로서 오리 입력 어레이 형상 물체를 수용한다. 우리가 호출 Array.apply(null, { length: N })하면 실행됩니다

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

이제 각 요소가로 설정된 N 요소 배열이 undefined있습니다. 호출하면 .map(callback, thisArg)각 요소는의 결과로 설정됩니다 callback.call(thisArg, element, index, array). 따라서 [undefined, undefined, …, undefined].map(Number.call, Number)각 요소를에 매핑합니다 (Number.call).call(Number, undefined, index, array). 이는 Number.call(undefined, index, array)앞에서 살펴본 바와 같이로 평가됩니다 index. 이것으로 요소가 인덱스와 같은 배열을 완성합니다.

왜 Array.apply(null, {length: N})그냥 대신에 문제를 겪고 Array(N)있습니까? 결국 두 표현식 모두 정의되지 않은 요소로 구성된 N 요소 배열이됩니다. 차이점은 이전 표현식에서, 각각의 요소가 명시되어있다 설정 후자에서, 각각의 요소가 설정되지 않았던 반면, 정의에 관한 것이다. 의 문서에 따르면 .map():

callback값이 할당 된 배열의 인덱스에 대해서만 호출됩니다. 삭제되었거나 값이 할당되지 않은 인덱스에 대해서는 호출되지 않습니다.

따라서 Array(N)충분하지 않습니다. Array(N).map(Number.call, Number)초기화되지 않은 길이 N의 배열이 생성됩니다 .

적합성

이 기술은 Function.prototype.apply()ECMAScript 5 에 지정된 동작에 의존하기 때문에 Chrome 14 및 Internet Explorer 9와 같은 ECMAScript 5 이전 브라우저 에서는 작동하지 않습니다 .

ES6를 사용하는 여러 가지 방법

스프레드 연산자 ( ...) 및 키 방법 사용

[ ...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 }해킹

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

일반화 된 양식에 대한 참고 사항

변경하여 거의 원하는 값으로 초기화 캔 생산 배열 위의 모든 형태 i+1(예 : 요구 표현 i*2, -i, 1+i*2, i%2등). 어떤 함수로 표현을 표현할 수 있다면 f첫 번째 형태는 단순히

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

예 :

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

이 배열로 초기화되기 때문에, undefined각 위치에서의 값이 v 될 것이다undefined

모든 양식을 보여주는 예

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)

사용자 정의 이니셜 라이저 기능을 사용하는보다 일반적인 예 f:

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

또는 더 간단한

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

배열은 본질적으로 길이를 관리합니다. 순회하면 인덱스를 메모리에 보관하고 해당 시점에서 참조 할 수 있습니다. 임의의 인덱스를 알아야 할 경우이 indexOf방법을 사용할 수 있습니다.

이것은 당신의 필요에 따라 특정 크기의 배열을 선언하고 싶을 수도 있습니다.

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

확산

스프레드 연산자 ( ...)와 keys메서드를 사용하면 인덱스를 생성하기 위해 N 크기의 임시 배열을 만든 다음 변수에 할당 할 수있는 새 배열을 만들 수 있습니다.

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

채우기 /지도

먼저 필요한 배열의 크기를 만들고 정의되지 않은 채로 채우고 map각 요소를 색인으로 설정 하는을 사용하여 새 배열을 만들 수 있습니다 .

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

배열

이것은 N 크기의 길이로 초기화되고 한 번에 배열을 채우는 것입니다.

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

위의 예제에서 주석과 혼란 대신 1..N의 값을 실제로 캡처하려면 몇 가지 옵션이 있습니다.

1. 색인이 사용 가능한 경우 간단히 1 씩 증가시킬 수 있습니다 (예 :) ++i.

2. 인덱스를 사용하지 않는 경우 (보다 효율적인 방법은) 배열을 만들지 만 N을 N + 1로 표시 한 다음 앞쪽으로 이동하는 것입니다.

   100 개의 숫자를 원한다면 :

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

ES6에서는 다음을 수행 할 수 있습니다.

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

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

편집 : 변경 Array(45)에 Array(N)당신이 질문을 업데이 트했습니다 때문이다.

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

매우 인기있는 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;
}

그런 다음

var foo = range(1, 5);

Javascript에는 기본 제공 방법이 없지만 두 번 이상 수행해야 할 경우 완벽하게 유효한 유틸리티 함수입니다.

편집 : 내 생각에 다음은 더 나은 범위 기능입니다. 아마 LINQ에 의해 편향되어 있기 때문에 더 많은 경우에 더 유용하다고 생각합니다. 귀하의 마일리지가 다를 수 있습니다.

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

Arrayv8 을 채우는 가장 빠른 방법 은 다음과 같습니다.

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

결과는 다음과 같습니다. [0, 1, 2, 3, 4]

이 질문에는 많은 복잡한 답변이 있지만 간단한 한 줄짜리가 있습니다.

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

또한 위의 내용을 작성하는 것이 짧고 깔끔하지만 다음은 약간 더 빠릅니다 (최대 길이).

127, Int8,

255, Uint8,

32,767, Int16,

65,535, Uint16,

2,147,483,647, Int32,

4,294,967,295, Uint32.

( max integer values 기준) 또한 Typed Arrays 에 대한 자세한 내용입니다 .

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

이 솔루션은 두 개의 배열을 만들고 추가 변수 선언 "$"을 사용하므로이 방법도 그리 이상적이지는 않습니다 (이 방법을 사용하여 해결할 방법은 확실하지 않습니다). 다음 솔루션이 가능한 가장 빠른 방법이라고 생각합니다.

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

이 문장을 작성한 후 언제든지 현재 범위에서 변수 "arr"을 간단하게 사용할 수 있습니다.

간단한 기능을 만들고 싶다면 (기본 검증을 통해) :

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

따라서 위의 기능을 사용하면 위의 초 저속 "단일 원 라이너"가 초고속, 심지어 더 짧아집니다.

range(1,14000);

이것을 사용할 수 있습니다 :

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

예를 들어

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

다음 배열을 만듭니다.

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

ES6이 트릭을 수행합니다.

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

결과를 확인하십시오.

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

내가 앱에서 d3.js 를 사용하는 경우 D3는이를 위해 돕는 도우미 기능을 제공합니다.

따라서 0에서 4까지의 배열을 얻으려면 다음과 같이 쉽습니다.

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

요청 한대로 1에서 5까지 배열을 가져옵니다.

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

자세한 내용은 이 튜토리얼 을 확인하십시오 .

ES2015 / ES6 스프레드 연산자 사용

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

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

이것은 아마도 숫자 배열을 생성하는 가장 빠른 방법 일 것입니다.

최단

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

인라인

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

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]

기능을 원하십니까?

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]

왜?

1. while 가장 빠른 루프입니다

2. 직접 설정이보다 빠릅니다. push

3. [] 보다 빠르다 new Array(10)

4. 짧습니다 ... 첫 번째 코드를보십시오. 여기에있는 다른 모든 기능을 살펴보십시오.

당신이 좋아하는 경우없이 살 수 없다 에 대한

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

또는

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

채우는 새로운 방법 Array은 다음과 같습니다.

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

결과는 다음과 같습니다. [0, 1, 2, 3, 4]

lodash를 사용하는 경우 _.range 를 사용할 수 있습니다 .

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

처음부터 끝까지 (포함하지 않음) 진행하는 숫자 배열 (양수 및 / 또는 음수)을 만듭니다. 음수 시작이 종료 또는 단계없이 지정된 경우 -1 단계가 사용됩니다. end를 지정하지 않으면 start로 시작하여 0으로 설정됩니다.

예 :

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

ES6을 사용하면 다음을 수행 할 수 있습니다.

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

최종 요약 보고서 .. Drrruummm Rolll-

이것은 인 짧은 코드 사이즈 N (여기서는 10)의 배열을 생성하기 ES6 사용없이 . 위의 Cocco 버전은 가깝지만 가장 짧지는 않습니다.

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

그러나이 코드 골프 의 확실한 승자 는 (최소 바이트의 소스 코드에서 특정 문제를 해결하기위한 경쟁) Niko Ruotsalainen 입니다. 배열 생성자와 ES6 스프레드 연산자 사용 . (대부분의 ES6 구문은 유효한 typeScript이지만 다음은 아닙니다. 사용하는 동안 신중해야합니다.)

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

ES6 에는 2 개의 인수 를 받는 Array.from 을 사용하는 또 다른 방법이 있습니다 . 첫 번째는 arrayLike (이 경우 length속성 이있는 객체 )이고 두 번째는 매핑 함수입니다 (이 경우에는 항목을 인덱스에 매핑합니다)

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

이것은 더 짧고 짝수를 생성하는 것과 같은 다른 시퀀스에 사용할 수 있습니다

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

또한 이것은 어레이를 통해 한 번만 반복되므로 대부분의 다른 방법보다 성능이 좋습니다. 스 니핏에서 일부 비교를 확인하십시오.

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

=>ES6 표준의 새로운 Array 메소드 및 함수 구문 사용 (작성 당시 Firefox 만 해당)

구멍을 채워서 undefined:

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

Array.from회전 "구멍"에 undefined너무 Array.map예상대로 작동합니다 :

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]

ES6에서 :

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

ES5 :

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

또 다른 ES6 버전.

Array.from두 번째 선택적 인수 를 사용하여 :

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

빈 Array(10)위치 에서 번호가 매겨진 배열을 만들 수 있습니다 .

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

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

현재이 완전한 답변 목록에없는 유일한 맛은 발전기를 갖춘 것이다. 이를 해결하기 위해 :

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

다음과 같이 사용할 수 있습니다.

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

이것에 대한 좋은 점은 증가시킬 필요가 없다는 것입니다 ... @ igor-shubin의 대답에서 영감을 얻으려면 매우 쉬운 무작위 배열을 만들 수 있습니다.

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

그리고 운영 비용이 오래 걸리는 것보다는 다음 과 같습니다.

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

대신 할 수 있습니다 :

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

Es6에서 배열 채우기 및 맵을 사용할 수 있습니다. 이 질문에 대한 답변에서 일부 사람들이 제안한 것처럼. 다음은 몇 가지 예입니다.

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]

나는 이것을 똑바로 쉽게 찾을 수 있기 때문에 이것을 선호합니다.

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

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

ES6 사용

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

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

를 반환 [0, 1, 2]합니다. Igor Shubin의 탁월한 답변 과 매우 유사 하지만 약간 덜 까다 롭고 한 문자 더 길었습니다.

설명:

• Array(3) // [undefined × 3]길이 n = 3의 배열을 생성하십시오. 불행히도이 배열은 우리에게 거의 쓸모가 없으므로 우리는 ...
• Array.apply(0,Array(3)) // [undefined, undefined, undefined]배열을 반복 가능하게 만듭니다. 참고 : null은 apply의 첫 번째 인수보다 일반적이지만 0은 짧습니다.
• Object.keys(Array.apply(0,Array(3))) // ['0', '1', '2'] 그런 다음 배열의 키를 가져옵니다 (배열은 typeof 배열이기 때문에 키에 대한 인덱스가있는 객체이기 때문에 작동합니다.
• Object.keys(Array.apply(0,Array(3))).map(Number) // [0, 1, 2] 문자열을 숫자로 변환하여 키 위에 매핑하십시오.