Aynı öğeyi birden çok kez tekrarlayan bir dizi oluşturma

[2]Liste olan Python'da aşağıdaki kod bu çıktıyı verir:

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

JavaScript'te bir dizi ile bunu yapmanın kolay bir yolu var mı?

Bunu yapmak için aşağıdaki işlevi yazdım, ama daha kısa veya daha iyi bir şey var mı?

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

Bunu şu şekilde yapabilirsiniz:

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

Her yinelemede diziyi ikiye katlar, böylece birkaç yinelemeyle gerçekten büyük bir dizi oluşturabilir.

Not: Her yinelemede yeni bir dizi oluşturacağınız gibi , pushyerine işlevinizi de geliştirebilirsiniz . Bunun gibi (dizilerle nasıl çalışabileceğinizin bir örneği olarak gösterilir):concatconcat

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

ES6'da Array fill () yöntemini kullanarak

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]

deneyebilirsin:

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

Güncelleme (01/06/2018) :

Artık bir dizi karakterin tekrarlanmasını sağlayabilirsiniz.

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

Not: hakkında daha kontrol edin dolgu (...) ve gelen (...) uyumluluk ve tarayıcı desteği için.

Güncelleme (11/05/2019) :

Herhangi bir uzunluktaki dize için çalışan fillveya kullanmadan başka bir yol from:

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

Yukarıdaki cevapla aynı . Bütünlük uğruna ekleme.

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

veya değeri artan dizi oluşturma

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

Gelen lodash o kadar kötü değil:

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

EDIT : Daha da iyisi:

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

EDIT : Daha da iyisi:

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

[c] * n şu şekilde yazılabilir:

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

için böylece [2] * 5

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

Array'ın işlevselliğini şu şekilde de genişletebilirsiniz:

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] 

Üçüncü taraf kitaplıklarla çalışıyorsanız, yerleşik nesnelerin işlevlerini genişletmenin sorunlara neden olabileceğini unutmayın. Bunu her zaman kararlarınıza tartın.

Node.js REPL'de:

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

Bir diziyi birkaç kez tekrarlamanız gerektiğinde :

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

bu cevaptan ilham aldı

Daha kolay bir yol yok. Bir döngü oluşturmalı ve öğeleri diziye itmelisiniz.

Bu işlevi kullanın:

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

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

Veya daha kompakt bir sürüm için:

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

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

Veya köri kullanabilen bir sürüm için:

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

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

Bu işlevi bir listeyle kullanabilirsiniz:

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

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

Bir diziyi tekrarlamanız gerekirse aşağıdakileri kullanın.

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

dönecek

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

Başka bir astar:

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

Bu işlev, (value) bir tamsayı veya bir tamsayı dizgisi olduğu sürece her öğenin (value) değerine eşit olduğu bir (length) öğesi dizisi oluşturur. Ondalık sayılar kesilir. Ondalık sayılar istiyorsanız, "parseInt ( " yerine " 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;
}

Örnekler:

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]

Gibi bir dizi kullandığımda belirtilen yöntemlerle ilgili sorunlar vardı

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

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

Bunu almak için kullanıyorum:

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

Bugün döngüler kullanmadan bir 2D dizi yapmaya çalışırken keşfettim. Retrospect'te, yeni bir diziye katılmak düzgün; Harita boş yuvaları atladığı gibi çalışmayan yeni bir dizi eşlemeyi denedim.

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

"#" Karakteri geçerli herhangi bir tek karakter olabilir. 5, istediğiniz öğe sayısı için bir değişken olacaktır. 7, dizinizi doldurmak istediğiniz değer olacaktır.

Yeni doldurma yöntemi daha iyidir ve bunu kodladığımda bunun var olduğunu bilmiyordum ve tekrarın es6 olduğunu da bilmiyordum; Havalı şeyler yapmak için indirimle birlikte bu hileyi birlikte kullanmayla ilgili bir blog yazısı yazacağım.

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

Bunu dene:

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

Lodash / alt çizgi gibi bir utlity kemer kullanıyorsanız bunu yapabilirsiniz :)

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

Tek astar olarak da kullanılabilir:

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

Vivek'in cevabını iyileştirerek , bu, n uzunluğunda bir diziyi doldurmak için herhangi bir uzunlukta dizgiler için çalışır:Array(n+1).join('[string to be repeated][separator]').split('[separator]').slice(0, n)

Bir kez tekrarlamak için bir yol gerekli (n öğeleri ile) m kez.

Örneğin, bir listenin (kişilerin) bir hafta / aya ​​dağıtılması. Diyelim ki 3 ismim var ve bir hafta içinde tekrar etmelerini istiyorum:

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