Buat array dengan elemen yang sama diulang beberapa kali

Dalam Python, di mana [2]ada daftar, kode berikut memberikan hasil ini:

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

Apakah ada cara mudah untuk melakukan ini dengan array di JavaScript?

Saya menulis fungsi berikut untuk melakukannya, tetapi apakah ada sesuatu yang lebih pendek atau lebih baik?

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

Anda dapat melakukannya seperti ini:

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

Ini menggandakan array di setiap iterasi, sehingga dapat membuat array yang sangat besar dengan beberapa iterasi.

Catatan: Anda juga dapat banyak meningkatkan fungsi dengan menggunakan pushalih-alih concat, karena concatakan membuat array baru setiap iterasi. Seperti ini (ditunjukkan hanya sebagai contoh bagaimana Anda dapat bekerja dengan array):

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

Dalam ES6 menggunakan Array fill () metode

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]

Anda dapat mencoba:

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

Pembaruan (01/06/2018) :

Sekarang Anda dapat memiliki satu set karakter yang berulang.

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

Catatan: Periksa lebih lanjut tentang isian (...) dan dari (...) untuk kompatibilitas dan dukungan browser.

Pembaruan (05/11/2019) :

Cara lain, tanpa menggunakan fillatau from, yang berfungsi untuk string dengan panjang berapa pun:

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

Sama seperti jawaban di atas . Menambah demi kelengkapan.

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

atau buat array dengan nilai yang meningkat

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

Di lodash tidak begitu buruk:

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

EDIT : Lebih baik lagi:

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

EDIT : Lebih baik lagi:

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

[c] * n dapat ditulis sebagai:

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

sehingga untuk [2] * 5

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

Anda juga dapat memperluas fungsionalitas Array seperti:

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] 

Saya harus mencatat bahwa memperluas fungsionalitas objek bawaan dapat menyebabkan masalah jika Anda bekerja dengan perpustakaan pihak ketiga. Selalu timbang ke dalam keputusan Anda.

Dalam REPL Node.js:

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

Jika Anda perlu mengulangi array beberapa kali:

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

terinspirasi oleh jawaban ini

Tidak ada cara yang lebih mudah. Anda perlu membuat lingkaran dan mendorong elemen ke dalam array.

Gunakan fungsi ini:

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

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

Atau untuk versi yang lebih ringkas:

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

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

Atau untuk versi kari:

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

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

Anda dapat menggunakan fungsi ini dengan daftar:

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

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

Jika Anda perlu mengulang array, gunakan yang berikut ini.

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

akan kembali

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

Satu kalimat lagi:

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

Fungsi ini menciptakan array elemen (panjang) di mana setiap elemen sama dengan (nilai) selama (nilai) adalah bilangan bulat atau string bilangan bulat. Angka desimal apa pun akan terpotong. Jika Anda ingin angka desimal, ganti "parseInt ( " dengan " 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;
}

Contoh:

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]

Saya punya masalah dengan metode yang disebutkan ketika saya menggunakan array seperti

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

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

Untuk mendapatkan ini saya menggunakan:

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

Saya menemukan ini hari ini ketika mencoba membuat array 2D tanpa menggunakan loop. Dalam retrospeksi, bergabung dengan array baru rapi; Saya mencoba memetakan array baru, yang tidak berfungsi karena peta melompati slot kosong.

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

Karakter "#" dapat berupa karakter tunggal apa pun yang valid. Angka 5 akan menjadi variabel untuk jumlah elemen yang Anda inginkan. 7 akan menjadi nilai yang Anda ingin isi dengan array Anda.

Metode pengisian baru lebih baik, dan ketika saya mengkodekan ini saya tidak tahu itu ada, saya juga tidak tahu bahwa pengulangan adalah es6; Saya akan menulis posting blog tentang menggunakan trik ini bersama-sama dengan mengurangi untuk melakukan hal-hal keren.

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

Coba ini:

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

Jika Anda menggunakan sabuk utlity seperti lodash / garis bawah Anda dapat melakukannya seperti ini :)

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

Dapat digunakan sebagai one-liner juga:

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

Meningkatkan pada jawaban Vivek , ini berfungsi untuk string dengan panjang berapa pun, untuk mengisi array dengan panjang n:Array(n+1).join('[string to be repeated][separator]').split('[separator]').slice(0, n)

Saya membutuhkan cara untuk mengulang / mengulangi array (dengan n item) m kali.

Misalnya, mendistribusikan daftar (orang) ke satu minggu / bulan. Katakanlah saya punya 3 nama, dan saya ingin mereka mengulanginya dalam seminggu:

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