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

Vous pouvez le faire comme ceci:

 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 dans chaque itération, de sorte qu'il peut créer un très grand tableau avec quelques itérations.

Remarque: Vous pouvez également améliorer votre fonction en utilisant push au lieu de concat , car concat crée un nouveau tableau chaque itération. Comme cela (illustré comme un 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; } 

Dans ES6 utilisant la méthode Array Fill ()

 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] 

tu peux essayer:

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

En 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); 

Vous pouvez également étendre la fonctionnalité de Array comme suit:

 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 dois noter que l'extension de la fonctionnalité des objets intégrés peut causer des problèmes si vous travaillez avec des bibliothèques tierces. Respectez toujours vos décisions.

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

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

Donc pour [2] * 5

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

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]

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

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

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 ce faire, 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; }; 

Un autre one-liner:

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

J'ai découvert cela aujourd'hui tout en essayant de faire un tableau 2D sans utiliser de boucles. Rétrospectivement, joindre un nouveau tableau est propre; J'ai essayé de mapper un nouveau tableau, ce qui ne fonctionne pas car la carte saute des machines à sous vides.

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

Le "#" char 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 avec laquelle vous souhaitez remplir votre tableau.

La nouvelle méthode de remplissage est meilleure, et lorsque j'ai codé cela, je ne savais pas qu'il existait, et je ne savais pas non plus, c'est es6; Je vais écrire une publication sur l'utilisation de cette astuce en tandem avec réduction pour faire des choses intéressantes.

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

Dans le cas où vous devriez répéter un tableau à plusieurs reprises:

 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

Si vous utilisez une ceinture utlity comme lodash / underscore, vous pouvez le faire comme ça 🙂

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

Peut être utilisé comme un one-liner aussi:

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