webentwicklung-frage-antwort-db.com.de

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

In Python, wo [2] ist eine Liste, der folgende Code gibt 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 dazu 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;
};
237
Curious2learn

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

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


Hinweis: Sie können Ihre Funktion auch erheblich verbessern, indem Sie Push anstelle von concat verwenden, da concat bei jeder Iteration ein neues Array erstellt. So (nur als Beispiel 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;
}
48
Guffa

In ES6 mit der Methode Array fill ()

Array(5).fill(2)
//=> [2, 2, 2, 2, 2]
513
>>> 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]
135
Janus Troelsen

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 ausfüllen (...) und von (...) finden Sie unter Kompatibilität und Browserunterstützung.

69
Vivek

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

oder erstellen Sie ein Array mit steigendem Wert

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

31
Thomson

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);
29
Droogans

[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;})
14
brook hong

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 bei Ihren Entscheidungen ab.

10
Shmiddty

Einfacher geht es nicht. Sie müssen eine Schleife erstellen und Elemente in das Array verschieben.

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 diese Antwort

3

Ein weiterer Einzeiler:

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

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 wünschen, 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]
1
TxRegex

Ich habe dies heute entdeckt, als ich versuchte, ein 2D-Array ohne Schleifen zu erstellen. Rückblickend ist der Beitritt zu einem neuen Array ordentlich. Ich habe versucht, ein neues Array zuzuordnen, was nicht funktioniert, da bei der Zuordnung leere Slots übersprungen werden.

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

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

Die neue Füllmethode ist besser, und als ich dies codierte, wusste ich nicht, dass es existiert, und ich wusste auch nicht, dass repeat es6 ist. Ich werde einen Blog-Beitrag darüber schreiben, wie man diesen Trick zusammen mit dem Reduzieren einsetzt, um coole Dinge zu machen.

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

1
Magical Gordon

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']
1
Ken Mueller
var finalAry = [..."2".repeat(5).split("")].map(Number);
console.log(finalAry);
1
Amaldev ps

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 das 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;
};
1
Xaver

Das Verbessern von Viveks Antwort funktioniert für Zeichenfolgen beliebiger Länge, um ein Array der Länge n aufzufüllen: Array(n+1).join('[string to be repeated][separator]').split('[separator]').slice(0, n)

0
Tigregalis

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;
}
0
Hai Phan

Versuche dies:

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

Wenn du einen Utility Belt wie lodash/underscore verwendest, kannst du das so machen :)

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