web-dev-qa-db-fra.com

Créer un tableau avec le même élément répété plusieurs fois

En Python, où [2] est une liste, le code suivant donne cette sortie:

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

Existe-t-il un moyen simple de faire cela avec un tableau en JavaScript?

J'ai écrit la fonction suivante pour le faire, mais y a-t-il quelque chose de plus court ou de mieux?

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;
};
javascriptarraysrepeat
237
Curious2learn

Vous pouvez le faire comme ça:

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

Il double le tableau à chaque itération, ce qui permet de créer un très grand tableau avec peu d'itérations.

Remarque: vous pouvez également beaucoup améliorer votre fonction en utilisant Push au lieu de concat, car concat créera un nouveau tableau à chaque itération. Comme ceci (montré juste à titre d'exemple de la façon dont vous pouvez travailler avec des tableaux):

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

Dans ES6 à l'aide de la méthode Array fill ()

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

tu peux essayer:

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

Mise à jour (01/06/2018):

Vous pouvez maintenant avoir un jeu de caractères répété.

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

Remarque: vérifiez plus à propos de remplissage (...) et de (...) pour la compatibilité et la prise en charge du navigateur.

69
Vivek

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

ou créer un tableau avec une valeur croissante

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

31
Thomson

Dans lodash ce n'est pas si grave:

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

EDIT: Encore mieux:

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

EDIT: Encore mieux:

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

[c] * n peut être écrit comme:

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

donc pour [2] * 5

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

Vous pouvez également étendre les fonctionnalités de Array de la manière suivante:

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]

Je devrais noter que l'extension de la fonctionnalité des objets intégrés peut poser des problèmes si vous travaillez avec des bibliothèques tierces. Toujours peser cela dans vos décisions.

10
Shmiddty

Pas de moyen plus facile. Vous devez créer une boucle et pousser des éléments dans le tableau.

3
Diodeus - James MacFarlane

Si vous devez répéter plusieurs fois un tableau :

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

inspiré par cette réponse

3
Henrik Christensen

Un autre one-liner:

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

Cette fonction crée un tableau d'éléments (longueur) où chaque élément est égal à (valeur) tant que (valeur) est un entier ou une chaîne de caractères d'un entier. Tous les nombres décimaux seront tronqués. Si vous voulez des nombres décimaux, remplacez "parseInt (" par "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;
}

Exemples:

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

J'ai découvert cela aujourd'hui en essayant de créer un tableau 2D sans utiliser de boucles. Rétrospectivement, rejoindre un nouveau tableau est génial; J'ai essayé de mapper un nouveau tableau, qui ne fonctionne pas car la carte ignore les emplacements vides.

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

Le caractère "#" peut être n'importe quel caractère unique valide. Le 5 serait une variable pour le nombre d'éléments que vous voulez. Le 7 serait la valeur que vous voulez remplir votre tableau.

La nouvelle méthode de remplissage est meilleure, et quand j’ai codé cela, je ne savais pas qu’elle existait, je ne savais pas que répéter était es6; Je vais écrire un article de blog sur l’utilisation de cette astuce en même temps que réduire pour faire des choses cool.

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

1
Magical Gordon

Utilisez cette fonction:

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

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

Ou pour une version plus compacte:

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

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

Ou pour une version curryable:

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

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

Vous pouvez utiliser cette fonction avec une liste:

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

J'ai eu des problèmes avec les méthodes mentionnées lorsque j'utilise un tableau comme

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

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

Pour obtenir cela, j'utilise:

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

Améliorant sur réponse de Vivek , cela fonctionne pour les chaînes de n'importe quelle longueur, pour remplir un tableau de longueur n: Array(n+1).join('[string to be repeated][separator]').split('[separator]').slice(0, n)

0
Tigregalis

Peut aussi être utilisé comme one-liner:

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

Essaye ça:

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

Si vous utilisez une ceinture utilitaire telle que lodash/underscore, vous pouvez le faire comme ceci :)

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