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 ce résultat:

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

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

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

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

Double Possible: stackoverflow.com/questions/1295584/...
double possible: stackoverflow.com/questions/1877475/repeat-character-n-times

InformationsquelleAutor Curious2learn | 2012-09-19

49

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 du tableau à chaque itération, de sorte qu'il peut réellement créer un grand tableau avec quelques itérations.

Remarque: Vous pouvez également améliorer votre fonction de beaucoup de choses en utilisant push au lieu de concat, comme concat permettra de créer un nouveau tableau à chaque itération. Comme ceci (montré 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;
}
```
- Il est beaucoup plus efficace d'attribuer toutes les entrées à l'avant, avec arr = new Array(len);, puis attribuez-leur index dans la boucle, c'est à dire arr[i] = value;. De cette façon, vous ne payez que O(n), plutôt que d'avoir à garder la réaffectation de la matrice à mesure qu'il grandit. En général, il est toujours préférable d'éviter de cultiver des tableaux en ajoutant si possible. Si vous connaissez la taille finale, l'utiliser.
- Array.from({length:5}).map(x => 2)
InformationsquelleAutor Guffa
482

Dans l'ES6 à l'aide du Tableau fill() méthode
```
Array(5).fill(2)
//=> [2, 2, 2, 2, 2]
```
- Internet Explorer et Opera ne le supporte pas encore.
- Node.js <= 3 ne prend pas en charge cette.
- Actuel de l'Opéra de ne. Et Bord trop. Voir compat-table
- Il existe une polyfill pour ceux qui manquent de soutien.
- Magnifiquement explicite.
- Toujours hors de la chance si vous le souhaitez (par exemple) à remplir plus d'une valeur de plus de et plus, par exemple [ 1, 2, 3, 1, 2, 3, ...]
- Vous pouvez le faire avec Array(5).fill([1,2,3]).flat(). Notez que plat() est encore très expérimentale et de la prise en charge du navigateur est pauvre.
- Notez que l'argument de fill est évaluée une fois, donc Array(9).fill(someMutable) crée neuf références à someMutable dans le tableau (mutation une mutation de 'tous').
InformationsquelleAutor Niko Ruotsalainen
131
```
>>> 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]
```
- Question bête, mais pourquoi new Array(10).la carte ne fonctionne pas?
- blazkovicz, voir zertosh commentaire de cette réponse pour la raison.
- Avec ES6, cela peut être "mis à jour" à Array(...Array(10)).map(() => 5) avec la propagation de l'opérateur ou également à Array.from(Array(10)).map(() => 5)
- Selon SOCIÉTÉ, vous pouvez simplement comme ceci: Array.from({length: 10}, () => 5);
- Tableau(10) crée un tableau de lenght = 10 sans propriétés énumérables. .map ne fonctionne que sur les propriétés énumérables. Le .apply méthode prend ce tableau, et des cartes dans un arguments array (un tableau comme objet) pour être transmis à la Array fonction constructeur. Le tableau arguments ne peuvent pas être rares, donc les propriétés manquantes préparez-vous à undefined et devenir énumérable. Maintenant, nous pouvons utiliser .map comme prévu
- Légère modification sur @ChristopheVidal commentaire: [...Array(10)].map(()=>5)
- Veuillez noter que l'ES6 version n'est pas en caractères d'imprimerie!
InformationsquelleAutor Janus Troelsen
64

vous pouvez essayer:
```
Array(6).join('a').split(''); //returns ['a','a','a','a','a'] (5 times)
```
Mise à jour (01/06/2018):

Maintenant vous pouvez avoir un ensemble de caractères de la répétition.
```
new Array(5).fill('a'); //give the same result as above;
//or
Array.from({ length: 5 }).fill('a')
```
Remarque: Vérifiez plus sur remplir(...) et à partir de(...) de compatibilité et de prise en charge du navigateur.
- Nice. Plus court et plus simple.
- +1 pour une manipulation simple. Une honte que vous ne pouvez pas créer un tableau de chaînes vides de cela. En dehors de cela très intelligent...
- Tableau(6).join('a').split('a') me donne un tableau de chaîne de caractères vide.
- Cela ne fonctionne que pour 1 char de chaînes, de sorte qu'il ne répond pas à la question complètement.
- Est-ce que chaque "un" un objet distinct? Ou fait-il référence au même objet?
- En Javascript, la Chaîne est une primitive (la valeur sémantique) type; il n'y a aucun moyen d'obtenir deux chaînes de référence, les mêmes données (parce que les chaînes de ne sont pas références en Javascript; ce sont des valeurs). Vous n'avez pas à surveiller de référence sémantique avec des objets et des listes, mais pas avec des chaînes.
InformationsquelleAutor Vivek
31

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

ou créer une matrice avec l'augmentation de la valeur

Array.from({length:5}, (e, i)=>i) //[0, 1, 2, 3, 4]
- Nice, c'est la meilleure approche si vous avez besoin de l'élément de dynamique
- Array.from({length:5}, i => 1) => i est undefined car il représente la valeur est vide Array.from({length:5}, (e, i)=>i) => e est undefined car il représente la valeur est vide. Il devrait être Array.from({length:5}, v => 1) et Array.from({length:5}, (v, i)=>i)
InformationsquelleAutor Thomson
29

Dans lodash c'est pas si mal:
```
_.flatten(_.times(5, function () { return [2]; }));
//[2, 2, 2, 2, 2]
```
MODIFIER: Encore mieux:
```
_.times(5, _.constant(2));
//[2, 2, 2, 2, 2]
```
MODIFIER: Encore mieux:
```
_.fill(Array(5), 2);
```
- _.fois(longueur, _.constant(valeur))
- Super-fonctionne également en underscore.js.
- à partir de la documentation : _.de remplissage(Array(3), 2); ce Qui n'est pas loin de l'ES6
InformationsquelleAutor Droogans
14

[c] * n peut être écrite comme:
```
Array(n+1).join(1).split('').map(function(){return c;})
```
donc pour [2] * 5
```
Array(6).join(1).split('').map(function(){return 2;})
```
- En fait, ne serait pas de Tableau(6).join(2).split (") - être plus facile? Pourquoi auriez-vous besoin de la carte?
- qui renvoie ["2", "2", "2", "2", "2"], au lieu de [2, 2, 2, 2, 2].
InformationsquelleAutor brook hong
10

Vous pouvez également étendre les fonctionnalités de Tableau 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] 
```
Il est à noter que l'extension de la fonctionnalité des objets intégrés peuvent causer des problèmes si vous travaillez avec de la 3e partie des bibliothèques. Pèse toujours présent dans vos décisions.
- Notez que si vous passez un objet dans fill chaque index dans le tableau se réfèrent au même objet, de sorte qu'un changement on va changer tous les d'entre eux. Ce n'est pas trop difficile à résoudre, si cela devient un problème.
- Je ne comprends pas pourquoi beaucoup de javascript utilisateurs ne sont pas conscients de l'exigence de ne pas le prototype des fonctions natives.
- Il n'y a aucune "obligation". C'est simplement une meilleure pratique lorsque l'on mélange les bibliothèques.
- méthode de remplissage a été ajouté dans l'ES6. Donc, je ne recommanderais pas à ajouter vos propres trucs pour le prototype, tu vas les remplacer le plus rapidement et le plus capable de version.
- vous devriez poster cette réponse.
- Pour éviter de remplacer javascript ou de la 3e partie des bibliothèques, vous pouvez vérifier s'il existe avant de la déclarer. if (!Array.prototype.fill) { }
- pourquoi ne pas simplement utiliser un vrai polyfill alors?
- Qu'entendez-vous par "réel polyfill"?. J'ai utilisé un polifyll. Je veux dire: vérifier la fonctionnalité de détection et de mise en œuvre dans le cas où il ne l'est pas.
InformationsquelleAutor Shmiddty
3

Pas de moyen plus facile. Vous avez besoin de faire une boucle et de pousser les éléments dans le tableau.
- Merci! Avant que j'accepte, est push mieux ou concat mieux, en termes d'efficacité?
- CONCAT doit inspecter les deux tableaux, appuyez simplement ajoute un autre élément, donc je m'attends à POUSSER à être plus efficace en général, mais pour les DONNÉES IDENTIQUES, je pense que Guffa de répondre à des clous.
- Pas besoin pour les boucles, voir ma réponse.
- pas besoin de boucle, sauf si vous voulez un moyen efficace pour faire cette action. Le vôtre est l'un des plus lent impementation vous pouvez trouver. push() de [] est le plus rapide.
InformationsquelleAutor Diodeus - James MacFarlane

Dans le cas où vous avez besoin de répéter une tableau plusieurs fois:

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

dans l'es6, vous pouvez le faire "abc".répéter(3)

InformationsquelleAutor Henrik Christensen

Un autre one-liner:

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

InformationsquelleAutor Filip Hermans

Cette fonction crée un tableau de (longueur) des éléments où chaque élément est égal à (valeur) tant que (valeur) est un entier ou une chaîne d'un nombre entier. Tout les nombres décimaux, il sera tronqué. Si vous ne souhaitez que des nombres décimaux, remplacer "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]

InformationsquelleAutor TxRegex

J'ai eu des problèmes avec les moyens mentionnés 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 ce que 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;
};

C'est gentil, mais devrait probablement être nommé cycle.

InformationsquelleAutor Xaver

1

J'ai découvert ça aujourd'hui, tout en essayant de faire un tableau 2D sans l'aide de boucles. Rétrospectivement, l'adhésion d'un nouveau tableau est bien, j'ai essayé la cartographie d'un nouveau tableau, qui ne fonctionne pas comme la carte saute logements vides.
```
"#".repeat(5).split('').map(x => 0)
```
Le "#" char peut être valable, toute seul caractère.
Le 5 serait une variable pour le nombre d'éléments que vous le souhaitez.
Le 7 serait la valeur que vous voulez remplir votre tableau avec.

La nouvelle méthode de remplissage est mieux, et quand j'ai codé ce que je ne savais pas qu'elle existait, et je ne savais répétition est es6; je vais écrire un billet de blog sur l'utilisation de cette astuce, en tandem avec la réduire à faire des choses cool.

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

InformationsquelleAutor Magical Gordon

JS:

var finalAry = [..."2".repeat(5).split("")].map(Number);
console.log(finalAry);

InformationsquelleAutor Amaldev ps

0

Si vous utilisez un utlity ceinture comme lodash souligné, vous pouvez le faire comme ceci 🙂
```
let result = _.map(_.times(foo), function() {return bar})
```
InformationsquelleAutor Shane Rogers

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

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

InformationsquelleAutor Hai Phan

0

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

InformationsquelleAutor Tigregalis
0

Essayez Ceci:
```
"avinash ".repeat(5).trim().split(" ");
```
InformationsquelleAutor Avinash

-1

J'ai besoin d'un moyen de répétition/boucle d'un tableau (avec n éléments) m fois.

Par exemple, la distribution d'une liste (des personnes) pour une semaine/mois. Disons que j'ai 3 noms, et je tiens à répéter dans une semaine:

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

InformationsquelleAutor akinuri

Vous devez vous connecter pour publier un commentaire.