Disons que j'ai un tableau:

var newArray = [];

Je peux y ajouter des chaînes comme ceci:

var thisString = 'watch';
newArray.push(thisString);

Ce que je veux faire, c'est avoir un tableau de cette chaîne. Ainsi, par exemple, je veux que newArray ait 50 de ces «thisString».

Je peux le faire facilement via une boucle:

for(var i=0;i<50;i++){
  newArray.push(thisString);
}

Mais disons que si j'ai 3 cordes:

var firstString = 'first', secondString = 'second', thirdString = 'third';

Et je veux pousser le troisième 30 fois, le deuxième 40 fois et le troisième 50 fois, est-ce la seule façon de le faire via la boucle ci-dessus? Ou puis-je dire

newArray.push(firstString * 50); //obviously not correct javascript (psuedo code)

Je veux le faire car dans mon projet, je pourrais avoir plus de 10 cordes. Je sais que c'est pour cela que les boucles sont construites, mais je me demandais s'il y avait des moyens plus simples de le faire.

JQuery peut être utilisé.

2
thatOneGuy 8 mars 2016 à 02:30

4 réponses

Meilleure réponse

Pour obtenir un tableau d'éléments répétés, vous pouvez utiliser cette approche:

var count = 3;
var sizedArray = Array.apply(null, Array(count));

Cela renvoie les éléments suivants:

[undefined, undefined, undefined]

Ensuite, vous pouvez utiliser map pour projeter la valeur souhaitée, vous donnant effectivement un tableau de la valeur répétée count fois:

var value = 'hello';
var result = sizedArray.map(function(o) {
    return value;
});
// ['hello', 'hello', 'hello']

En mettant tout cela ensemble, votre demande pourrait être résolue comme suit:

function generateArray(value, size) {
  var sizedArray = Array.apply(null, Array(size));
  var result = sizedArray.map(function() {
    return value;
  });
  return result;
}

var firstArray = generateArray('first', 5);
var secondArray = generateArray('second', 10);
var thirdArray = generateArray('third', 15);
var result = firstArray.concat(secondArray).concat(thirdArray);
console.log(result);

Cette approche fonctionnera avec n'importe quelle chaîne, même celles avec des virgules, car nous n'adoptons pas une approche qui se divise en virgules similaire à la solution dans les commentaires qui fonctionnerait pour un ensemble limité d'entrées.

JSBin: lien de démonstration

Alternativement, si vous utilisez LoDash, vous pouvez utiliser la _.range méthode pour générer un tableau à map, ce qui remplacerait mon utilisation de Array.apply ci-dessus:

var range = _.range(4);
// [0, 1, 2, 3]
2
Ahmad Mageed 7 mars 2016 à 23:58

Pourquoi ne pas le faire comme ça. c'est la solution la plus simple.

String.prototype.rtoArray = function(number) {
  retArray = Array();
  for (i = 0; i < number; i++) {
    retArray[i] = String(this);
  }
  return retArray;
}

firstString = "first".rtoArray(50);
secondString = "second".rtoArray(40);
thirdString = "third".rtoArray(30);

Le résultat est que firstString aura 50 fois avec la "première" valeur de chaîne, secondString aura 40 fois avec la "deuxième" valeur de chaîne, et thirdString aura 30 fois avec la "troisième" valeur de chaîne. (les résultats sont dans le tableau).

0
Gian Lorenzo Abaño 8 mars 2016 à 01:24

Je ne suis pas sûr de bien comprendre votre sortie souhaitée, mais cela pourrait être le bon code. Cela créera un tableau de longueur c, puis remplira chaque index avec la chaîne s.

function stringArrMaker(s, c) {
    return "#".repeat(c).split("").map(function () {
        return s;
    });
}

console.log(stringArrMaker("hello", 10));

C'est une façon idiote de remplir un tableau avec c nombre de valeurs. String.repeat() prendra une chaîne et "répéter" dans la chaîne. Donc "#".repeat(3); crée ### puis vous split() pour créer un tableau de la longueur que vous souhaitez.

Notez que String.repeat() le fait ne bénéficient pas d'un large soutien. Vous pouvez donc préférer Array.apply(null, Array(count)); à la place. Je l'utilise juste pour le golf de code.

Sortie

[ 'hello',
  'hello',
  'hello',
  'hello',
  'hello',
  'hello',
  'hello',
  'hello',
  'hello',
  'hello' ]
1
zero298 8 mars 2016 à 00:43

Je ne sais pas du tout pourquoi ce que vous faites est pratique, mais cela pourrait peut-être aider:

function arrayOfSameStrings(repeatString, times){
  var r = [];
  for(var i=0,l=times; i<l; i++){
    r.push(repeatString);
  }
  return r;
}
var ary = arrayOfSameStrings('Bad Idea', 30);
console.log(ary);
0
StackSlave 8 mars 2016 à 00:42