同じ要素を複数回繰り返して配列を作成する

Pythonでは、[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;
}

反復ごとに配列を2倍にするため、反復回数が少ない非常に大きな配列を作成できます。

注：のpush代わりにを使用して関数を大幅に改善することもできます。繰り返しごとに新しい配列が作成さconcatれconcatます。このように（配列を操作する方法の例としてのみ示されています）：

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)

アップデート（2018年1月6日）：

これで、一連の文字を繰り返すことができます。

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

注：互換性とブラウザのサポートについては、fill（...）とfrom（...）の詳細を確認してください。

アップデート（2019年5月11日）：

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

この関数は、（値）が整数または整数の文字列である限り、各要素が（値）と等しい（長さ）要素の配列を作成します。10進数は切り捨てられます。10進数が必要な場合は、"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は、配列に入力する値です。

新しいfillメソッドの方が優れています。これをコーディングしたとき、それが存在することも知らなかったし、繰り返しがes6であることも知りませんでした。私は、reduceと組み合わせてこのトリックを使用してクールなことを行うことについてブログ投稿を作成します。

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つの名前があり、それらを1週間で繰り返したいとします。

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