동일한 요소가 여러 번 반복되는 배열 만들기

파이썬에서 [2]리스트가있는 곳 에서 다음 코드는이 출력을 제공합니다.

[2] * 5 # Outputs: [2,2,2,2,2]

JavaScript의 배열로 이것을 수행하는 쉬운 방법이 있습니까?

나는 그것을하기 위해 다음 함수를 작성했지만 더 짧거나 더 좋은 것이 있습니까?

var repeatelem = function(elem, n){
    // returns an array with element elem repeated n times.
    var arr = [];

    for (var i = 0; i <= n; i++) {
        arr = arr.concat(elem);
    };

    return arr;
};

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

function fillArray(value, len) {
  if (len == 0) return [];
  var a = [value];
  while (a.length * 2 <= len) a = a.concat(a);
  if (a.length < len) a = a.concat(a.slice(0, len - a.length));
  return a;
}

각 반복마다 배열을 두 배로 늘리므로 반복 횟수가 거의없는 매우 큰 배열을 만들 수 있습니다.

참고 : 반복 할 때마다 새 배열을 만들 므로 push대신 대신을 사용하여 함수를 크게 향상시킬 수 있습니다 . 이와 같이 (배열로 작업하는 방법의 예와 같이) :concatconcat

function fillArray(value, len) {
  var arr = [];
  for (var i = 0; i < len; i++) {
    arr.push(value);
  }
  return arr;
}

ES6에서 Array fill () 메소드 사용

Array(5).fill(2)
//=> [2, 2, 2, 2, 2]

>>> Array.apply(null, Array(10)).map(function(){return 5})
[5, 5, 5, 5, 5, 5, 5, 5, 5, 5]
>>> //Or in ES6
>>> [...Array(10)].map((_, i) => 5)
[5, 5, 5, 5, 5, 5, 5, 5, 5, 5]

당신은 시도 할 수 있습니다:

Array(6).join('a').split(''); // returns ['a','a','a','a','a'] (5 times)

업데이트 (01/06/2018) :

이제 일련의 문자를 반복 할 수 있습니다.

new Array(5).fill('a'); // give the same result as above;
// or
Array.from({ length: 5 }).fill('a')

참고 : 호환성 및 브라우저 지원에 대해서는 fill (...) 및 from (...) 에 대해 자세히 확인하십시오 .

업데이트 (05/11/2019) :

또 다른 방법, 사용하지 않고 fill또는 from어떤 길이의 문자열에 대한 그 작품을 :

Array.apply(null, Array(3)).map(_ => 'abc') // ['abc', 'abc', 'abc']

위의 답변 과 동일합니다 . 완전성을 위해 추가.

Array.from({length:5}, i => 1) // [1, 1, 1, 1, 1]

또는 가치가 증가하는 배열을 만듭니다

Array.from({length:5}, (e, i)=>i) // [0, 1, 2, 3, 4]

lodash 에서는 그렇게 나쁘지 않습니다.

_.flatten(_.times(5, function () { return [2]; }));
// [2, 2, 2, 2, 2]

편집 : 더 나은 :

_.times(5, _.constant(2));
// [2, 2, 2, 2, 2]

편집 : 더 나은 :

_.fill(Array(5), 2);

[c] * n 다음과 같이 쓸 수 있습니다 :

Array(n+1).join(1).split('').map(function(){return c;})

그래서 [2] * 5

Array(6).join(1).split('').map(function(){return 2;})

Array의 기능을 다음과 같이 확장 할 수도 있습니다.

Array.prototype.fill = function(val){
    for (var i = 0; i < this.length; i++){
        this[i] = val;
    }
    return this;
};
// used like:
var arry = new Array(5)​.fill(2);
// or
var arry = new Array(5);
arry.fill(2);


​console.log(arry);​ //[2, 2, 2, 2, 2] 

내장 라이브러리의 기능을 확장하면 타사 라이브러리로 작업하는 경우 문제가 발생할 수 있습니다. 항상 결정에 무게를 두십시오.

Node.js REPL에서 :

> Array.from({length:5}).map(x => 2)
[ 2, 2, 2, 2, 2 ]

배열을 여러 번 반복해야하는 경우 :

var arrayA = ['a','b','c'];
var repeats = 3;
var arrayB = Array.apply(null, {length: repeats * arrayA.length})
        .map(function(e,i){return arrayA[i % arrayA.length]});
// result: arrayB = ['a','b','c','a','b','c','a','b','c']

이 답변에서 영감을 얻은

더 쉬운 방법은 없습니다. 루프를 만들고 요소를 배열로 밀어 넣어야합니다.

이 기능을 사용하십시오 :

function repeatElement(element, count) {
    return Array(count).fill(element)
}

>>> repeatElement('#', 5).join('')
"#####"

또는보다 컴팩트 한 버전의 경우 :

const repeatElement = (element, count) =>
    Array(count).fill(element)

>>> repeatElement('#', 5).join('')
"#####"

또는 카레 가능 버전의 경우 :

const repeatElement = element => count =>
    Array(count).fill(element)

>>> repeatElement('#')(5).join('')
"#####"

이 기능을 목록과 함께 사용할 수 있습니다.

const repeatElement = (element, count) =>
    Array(count).fill(element)

>>> ['a', 'b', ...repeatElement('c', 5)]
['a', 'b', 'c', 'c', 'c', 'c', 'c']

배열을 반복해야하는 경우 다음을 사용하십시오.

Array.from({ length: 3 }).fill(['a','b','c']).flat()

돌아올 것이다

Array(9) [ "a", "b", "c", "a", "b", "c", "a", "b", "c" ]

다른 하나의 라이너 :

Array.prototype.map.call([]+Array(5+1),function(){ return '2'; })

이 함수는 (값)이 정수 또는 정수 문자열 인 한 각 요소가 (값) 인 (길이) 요소의 배열을 만듭니다. 십진수는 잘립니다. 십진수를 원하면 "parseInt ( "를 " parseFloat ( "

function fillArray(length, intValue) {
     var vals = (new Array(length + 1)).join(intValue + '|').split('|').slice(0,length);
     for(var i = 0; i < length; i += 1) {
         vals[i] = parseInt(vals[i]);
     }
     return vals;
}

예 :

fillArray(5, 7) // returns [7,7,7,7,7]
fillArray(5, 7.5) // returns [7,7,7,7,7]
fillArray(5, 200) // returns [200,200,200,200,200]

배열을 사용할 때 언급 한 방법에 문제가 있습니다.

var array = ['foo', 'bar', 'foobar'];
var filled = array.fill(7);

//filled should be ['foo', 'bar', 'foobar', 'foo', 'bar', 'foobar', 'foo']

이것을 얻으려면 사용하고 있습니다 :

Array.prototype.fill = function(val){
    var l = this.length;
    if(l < val){
        for(var i = val-1-l; i >= 0; i--){
            this[i+l] = this[i % l];
        }
    }
    return this;
};

루프를 사용하지 않고 2D 배열을 만들려고 오늘 이것을 발견했습니다. 돌이켜 보면 새 배열에 가입하는 것이 깔끔합니다. 맵이 빈 슬롯을 건너 뛸 때 작동하지 않는 새 배열을 매핑하려고했습니다.

"#".repeat(5).split('').map(x => 0)

"#"문자는 유효한 단일 문자 일 수 있습니다. 5는 원하는 요소 수에 대한 변수입니다. 7은 배열을 채우려는 값입니다.

새로운 채우기 방법이 더 좋으며, 이것을 코딩 할 때 그것이 존재하는지 알지 못했고 반복이 es6라는 것을 알지 못했습니다. 멋진 일을 줄이기 위해이 트릭을 사용하는 방법에 대한 블로그 게시물을 작성하려고합니다.

http://jburger.us.to/2016/07/14/functionally-create-a-2d-array/

이 시도:

"avinash ".repeat(5).trim().split(" ");

lodash / underscore와 같은 utlity 벨트를 사용하는 경우 다음과 같이 할 수 있습니다 :)

let result = _.map(_.times(foo), function() {return bar})

단일 라이너로도 사용할 수 있습니다.

function repeat(arr, len) {
    while (arr.length < len) arr = arr.concat(arr.slice(0, len-arr.length));
    return arr;
}

Vivek의 답변을 개선 하면 길이 n의 배열을 채우기 위해 모든 길이의 문자열에 작동합니다.Array(n+1).join('[string to be repeated][separator]').split('[separator]').slice(0, n)

배열 (n 항목)을 m 번 반복 / 반복하는 방법이 필요했습니다.

예를 들어 (사람의) 목록을 주 / 월에 배포합니다. 3 개의 이름이 있는데 일주일에 반복하고 싶다고 가정 해 봅시다.

fillArray(["Adam", "Blair", "Curtis"], 7); // returns ["Adam", "Blair", "Curtis", "Adam", "Blair", "Curtis", "Adam"]

function fillArray(pattern, count) {
    let result = [];
    if (["number", "string"].includes(typeof pattern)) {
        result = new Array(5);
        result.fill(pattern);
    }
    else if (pattern instanceof Array) {
        for (let i = 0; i < count; i++) {
            result = result.concat(pattern);
        }
        result = result.slice(0, count);
    }
    return result;
}

fillArray("a", 5);        // ["a", "a", "a", "a", "a"]
fillArray(1, 5);          // [1, 1, 1, 1, 1]
fillArray(["a", "b"], 5); // ["a", "b", "a", "b", "a"]