1을 포함하는 어레이를 작성하는 방법...n

1을 포함하는 어레이를 작성하는 방법...n

실행 시에만 N을 알 수 있는 1~N을 포함하는 JavaScript 배열을 작성하기 위해 다음과 같은 대안을 찾고 있습니다.

var foo = [];

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

내게는 루프가 없이 이것을 할 수 있는 방법이 있어야 한다고 생각한다.

ES6에서는 어레이 및 메서드를 사용합니다.

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]

맵 함수를 Array에 전달하여1부터 시작합니다.이 때 오브젝트는length★★★★

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

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

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.8567485427297653848143294454, 0.00339877473190427, 0.99117566226026, 0.8133423990990467, 0.87585598880848480464646464454454]

설명.

해 주세요.Number.call(undefined, N) Number(N)돌아온다N그 사실은 나중에 사용하겠습니다.

Array.apply(null, [undefined, undefined, undefined]) Array(undefined, undefined, undefined)되어 3개의 "R"이 할당됩니다undefined각 요소에 대해 설명합니다.

어떻게 N개의 요소로 일반화할 수 있습니까?의 동작에 대해 생각해 봅시다.이것은 다음과 같습니다.

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-element 어레이가 있습니다.undefined호출하면 각 요소가 다음 결과로 설정됩니다.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-element 배열이 됩니다.차이점은 전자의 식에서는 각 요소가 명시적으로 정의되지 않음으로 설정되어 있는 반면 후자의 식에서는 각 요소가 설정되지 않았다는 것입니다.의 설명서에 따르면:

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

therefore그 、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.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)

것을 수 , .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/ 를 참조해 주세요.

어레이는 본래 길이를 관리합니다.이러한 인덱스를 통과할 때 인덱스를 메모리에 보관하고 해당 시점에서 참조할 수 있습니다. 필요가 는, 「」를 해 주세요.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

퍼지다

연산자스프레드 연산자)의... 및 )의 개요keysmethod 할 수 있습니다.그 후할 수 을 만듭니다.method : od method method 、 N 、 음 method음 method 。

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

채우기/지도

를 먼저 새로 .map각 요소를 인덱스로 설정합니다.

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

Array.from

이것은 크기 N의 길이로 초기화하고 어레이를 한 번에 채웁니다.

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

---

코멘트나 혼란 대신에, 1부터의 값을 정말로 캡처하고 싶은 경우.위의 예에서는 두 가지 옵션이 있습니다.

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

널리 사용되는 언더스코어 _.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;
}

채울 수 있는 Array은 다음과 같습니다

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

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

이 질문에는 복잡한 답변이 많지만 간단한 답변이 하나 있습니다.

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

---

또, 상기의 기입은 짧지만(또, 깔끔하게), 이하가 조금 빠르다고 생각합니다(최대 길이:

127, 내선번호8

255, Uint8,

32,767,Int16,

65,535, Uint16,

2,147,483,647,Int32,

4,294,967,295, Uint32.

(최대 정수치에 근거합니다).또한 Type Array에 대한 자세한 내용은 다음과 같습니다.

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

이 솔루션도 2개의 어레이를 생성하고 추가 변수 선언 "$"를 사용하기 때문에 그다지 이상적인 솔루션은 아닙니다(이 방법을 사용하여 이 문제를 해결할 방법은 없습니다).이를 위해서는 다음 솔루션이 가장 빠른 방법이라고 생각합니다.

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

ES2015/ES6 확산 연산자 사용

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

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

다음을 사용할 수 있습니다.

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]

만약 당신이 저처럼 당신의 앱에서 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]

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

성능

오늘 2020.12.11 Chrome v87, Safari v13.1.2 및 Firefox v83에서 MacOs HighSierra 10.13.6에서 선택한 솔루션을 테스트합니다.

결과.

모든 브라우저용

• 솔루션 O(기준)while 그 경우는 가빠릅니다(Firefox n N n N 만 N 만 、 만 N 만 、 만 、 우 、 우 N 、 ) 、 우 ) ) 。
• 솔루션 T는 Firefox에서 빅N으로 가장 빠릅니다.
• 솔루션 M,P는 소형 N에 대해 고속입니다.
• 솔루션 V(lodash)는 빅 엔에 매우 적합합니다.
• 솔루션 W,X는 작은 N에 대해 느립니다.
• 솔루션 F가 느리다

세부 사항

2가지 테스트 케이스를 수행합니다.

• 작은 N = 10의 경우 - 여기에서 실행할 수 있습니다.
• 빅 N = 1000000의 경우 - 여기에서 실행할 수 있습니다.

아래 스니펫은 테스트된 모든 솔루션 A B C D E F G H I J K L M N O P Q R S U V X를 나타냅니다.

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

function B(N) {
  return Array(N).fill().map((_, i) => i+1);
}

function C(N) {
  return Array(N).join().split(',').map((_, i) => i+1 );
}

function D(N) {
  return Array.from(Array(N), (_, i) => i+1)
}

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

function F(N) {
  return Array.from({length:N}, Number.call, i => i + 1)
}

function G(N) {
  return (Array(N)+'').split(',').map((_,i)=> i+1)
}

function H(N) {
  return [ ...Array(N).keys() ].map( i => i+1);
}

function I(N) {
  return [...Array(N).keys()].map(x => x + 1);
}

function J(N) {
  return [...Array(N+1).keys()].slice(1)
}

function K(N) {
  return [...Array(N).keys()].map(x => ++x);
}

function L(N) {
  let arr; (arr=[ ...Array(N+1).keys() ]).shift();
  return arr;
}

function M(N) {
  var arr = [];
  var i = 0;

  while (N--) arr.push(++i);

  return arr; 
}

function N(N) {
  var a=[],b=N;while(b--)a[b]=b+1;
  return a;
}

function O(N) {
  var a=Array(N),b=0;
  while(b<N) a[b++]=b;
  return a;
}

function P(N) {
  var foo = [];
  for (var i = 1; i <= N; i++) foo.push(i);
  return foo;
}

function Q(N) {
  for(var a=[],b=N;b--;a[b]=b+1);
  return a;
}

function R(N) {
  for(var i,a=[i=0];i<N;a[i++]=i);
  return a;
}

function S(N) {
    let foo,x;
    for(foo=[x=N]; x; foo[x-1]=x--);
  return foo;
}

function T(N) {
  return new Uint8Array(N).map((item, i) => i + 1);
}

function U(N) {
  return '_'.repeat(5).split('').map((_, i) => i + 1);
}

function V(N) {
  return _.range(1, N+1);
}

function W(N) {
  return [...(function*(){let i=0;while(i<N)yield ++i})()]
}

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

  return [...sequence(N)];
}


[A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X].forEach(f=> {
  console.log(`${f.name} ${f(5)}`);
})

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.20/lodash.min.js" integrity="sha512-90vH1Z83AJY9DmlWa8WkjkV79yfS2n2Oxhsi2dZbIv0nC4E6m5AbH8Nh156kkM7JePmqD6tcZsfad1ueoaovww==" crossorigin="anonymous"> </script>
  
This shippet only presents functions used in performance tests - it not perform tests itself!

다음은 Chrome의 예시 결과입니다.

이것이 일련의 숫자를 생성하는 가장 빠른 방법일 것입니다.

최단

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. 설정이 is보다 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]

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

Array 말합니다

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

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

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)

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

델타 포함

javascript의 경우

smallest and one-liner

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

예 및 기타 대안

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]

Range Function

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]

As Iterators

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

As Generators Only

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
// ...

단계/델타 포함 시작부터 종료

using iterators

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]

using Generators

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

타이프 스크립트의 경우

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

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

이것은 ES6를 사용하지 않고 N사이즈(여기서는 10)의 배열을 생성하기 위한 최단 코드입니다.위의 Cocco 버전은 가깝지만 최단 버전은 아닙니다.

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

그러나 이 코드 골프(소스 코드의 최소 바이트로 특정 문제를 해결하기 위한 경쟁)의 확실한 승자는 Niko Ruotsalainen입니다.Array Constructor와 ES6 확산 연산자를 사용합니다.(ES6 구문의 대부분은 유효한 typeScript이지만 다음 구문은 유효하지 않습니다.)신중하게 사용하세요)

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

매우 단순하고 정확하게 1 - N 생성하기 쉽습니다.

const [, ...result] = Array(11).keys();

console.log('Result:', result);

ES6에서는 Array.를 사용하여2개의 인수를 취득할 수 있습니다.첫 번째 방법은 arrayLike입니다(이 경우 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")

빠른

이 솔루션은 lodash_.range 함수에서 영감을 얻은 것이 가장 빠를 것입니다(단, 이 솔루션이 더 간단하고 빠릅니다).

let N=10, i=0, a=Array(N);

while(i<N) a[i++]=i;



console.log(a);

보다 퍼포먼스가 합니다.(2020.12.11)에 하고 있습니다.while/for

• 에 한 번 됩니다.a=Array(N)
• 상승i++- 지수 보다 30%.i--일 수 ) (CPU 캐시 메모리)

이 답변에서는 20개 이상의 다른 솔루션을 사용한 속도 테스트를 실시했습니다.

및 " " 사용"=>ES6는 ES6를 사용하고 있습니다(ES6는 ES6를 사용하고 있습니다.

멍 with with with with with with로 undefined

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

Array.from을 '구멍'으로 바꾸다undefinedArray.map정상적으로 동작합니다.

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

ES6의 경우:

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

경우 및 경우)slice : 디세이블화):

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

또는 조금 더 빠른 결과를 얻기 위해 목록이 256개보다 짧은 경우 Uint8Array를 사용할 수 있습니다(또는 목록이 얼마나 짧은지에 따라 최대 65535개의 Uint16 또는 최대 4294967295개의 Uint32 등).공식적으로 이러한 유형의 어레이는 ES6에서만 추가되었습니다.)예를 들어 다음과 같습니다.

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

ES5:

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

('ES5'의 두 )Array.from). Number.callNumber.call 을 할 수 .

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

은 반대하시는 분은 반대하시는 분입니다..slice또한 다음과 같이 (ES6에서) 위와 동등한 ES5를 실행할 수 있습니다.

Array.apply(0,{length:1000}).map(Number.call, Function("i","return i+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]

현재 이 다소 완전한 답변 목록에 없는 유일한 맛은 제너레이터가 장착된 것 같습니다. 따라서 다음과 같은 문제를 해결합니다.

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})()]

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

훔치기Number.call를 쓰다fill()이상에서만 합니다.ES6 이 es es es es es es es es es es es 。

Es6에서 Array fill 및 map을 사용할 수 있습니다.이 질문에 대한 답변에서 제시된 일부 사용자처럼요.다음은 몇 가지 예입니다.

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]

직설적이고 쉽기 때문에 이것을 선호합니다.

언급URL : https://stackoverflow.com/questions/3746725/how-to-create-an-array-containing-1-n