Erstellen Sie ein Array mit demselben Element, das mehrmals wiederholt wird

In Python, wo [2]sich eine Liste befindet, gibt der folgende Code diese Ausgabe aus:

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

Gibt es eine einfache Möglichkeit, dies mit einem Array in JavaScript zu tun?

Ich habe die folgende Funktion geschrieben, aber gibt es etwas kürzeres oder besseres?

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

Sie können es so machen:

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

Das Array wird in jeder Iteration verdoppelt, sodass mit wenigen Iterationen ein wirklich großes Array erstellt werden kann.

Hinweis: Sie können Ihre Funktion auch erheblich verbessern, indem Sie pushanstelle von verwenden concat, da concatbei jeder Iteration ein neues Array erstellt wird. So (nur als Beispiel dafür gezeigt, wie Sie mit Arrays arbeiten können):

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

In ES6 mithilfe der Array fill () -Methode

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]

Du kannst es versuchen:

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

Update (01/06/2018) :

Jetzt können Sie eine Reihe von Zeichen wiederholen lassen.

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

Hinweis: Weitere Informationen zu Kompatibilität (...) und von (...) finden Sie auf Kompatibilität und Browserunterstützung.

Update (11.05.2019) :

Eine andere Möglichkeit, ohne filloder zu verwenden from, funktioniert für Zeichenfolgen beliebiger Länge:

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

Gleich wie oben Antwort . Der Vollständigkeit halber hinzufügen.

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

oder erstellen Sie ein Array mit zunehmendem Wert

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

In lodash ist es nicht so schlimm:

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

EDIT : Noch besser:

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

EDIT : Noch besser:

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

[c] * n kann geschrieben werden als:

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

so für [2] * 5

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

Sie können die Funktionalität von Array auch folgendermaßen erweitern:

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] 

Ich sollte beachten, dass das Erweitern der Funktionalität von integrierten Objekten Probleme verursachen kann, wenn Sie mit Bibliotheken von Drittanbietern arbeiten. Wägen Sie dies immer in Ihre Entscheidungen ein.

In der Node.js REPL:

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

Falls Sie ein Array mehrmals wiederholen müssen :

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

inspiriert von dieser Antwort

Kein einfacher Weg. Sie müssen eine Schleife erstellen und Elemente in das Array verschieben.

Verwenden Sie diese Funktion:

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

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

Oder für eine kompaktere Version:

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

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

Oder für eine Curry-fähige Version:

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

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

Sie können diese Funktion mit einer Liste verwenden:

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

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

Wenn Sie ein Array wiederholen müssen, verwenden Sie Folgendes.

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

wird zurückkehren

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

Ein weiterer Einzeiler:

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

Diese Funktion erstellt ein Array von (Längen-) Elementen, wobei jedes Element gleich (Wert) ist, solange (Wert) eine Ganzzahl oder eine Zeichenfolge einer Ganzzahl ist. Alle Dezimalzahlen werden abgeschnitten. Wenn Sie Dezimalzahlen möchten, ersetzen Sie "parseInt ( " durch " 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;
}

Beispiele:

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]

Ich hatte Probleme mit den genannten Methoden, wenn ich ein Array wie

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

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

Um dies zu bekommen, benutze ich:

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

Ich habe dies heute entdeckt, als ich versucht habe, ein 2D-Array ohne Schleifen zu erstellen. Rückblickend ist das Verbinden eines neuen Arrays ordentlich. Ich habe versucht, ein neues Array zuzuordnen, was nicht funktioniert, da die Zuordnung leere Slots überspringt.

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

Das Zeichen "#" kann ein beliebiges gültiges Einzelzeichen sein. Die 5 wäre eine Variable für die Anzahl der gewünschten Elemente. Die 7 wäre der Wert, mit dem Sie Ihr Array füllen möchten.

Die neue Füllmethode ist besser, und als ich sie codierte, wusste ich nicht, dass sie existiert, und ich wusste auch nicht, dass Wiederholung es6 ist. Ich werde einen Blog-Beitrag über die Verwendung dieses Tricks in Verbindung mit Reduzieren schreiben, um coole Dinge zu tun.

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

Versuche dies:

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

Wenn Sie einen Utlity-Gürtel wie lodash / underscore verwenden, können Sie dies so tun :)

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

Kann auch als Einzeiler verwendet werden:

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

Dies verbessert die Antwort von Vivek und funktioniert für Zeichenfolgen beliebiger Länge, um ein Array mit der Länge n zu füllen:Array(n+1).join('[string to be repeated][separator]').split('[separator]').slice(0, n)

Ich brauchte eine Möglichkeit, ein Array (mit n Elementen) m-mal zu wiederholen / zu schleifen.

Verteilen Sie beispielsweise eine Liste (von Personen) auf eine Woche / einen Monat. Nehmen wir an, ich habe drei Namen und möchte, dass sie sich in einer Woche wiederholen:

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