En python, vous pouvez faire:
let arr2 = [...arr, ...arr, ...arr]
sortie:
[1,2,3,1,2,3,1,2,3]
Existe-t-il une manière concise de faire cela en script java? Le mieux auquel je puisse penser est quelque chose comme:
arr = [1,2,3] * 3 print(arr)
mais si je voulais faire cela 100 fois, ce ne serait pas pratique. En python, je le multiplierais simplement par 100.
6 Réponses :
Vous pouvez faire ceci:
var repeated = new Array(100).fill([1, 2, 3]).flat();
Cela crée un tableau d'une longueur donnée (100 ici) et le remplit avec le tableau à répéter ( [1, 2, 3 ] ). Ce tableau est ensuite réparti en tant que liste d'arguments vers [[ .concat().
Oh attendez juste
var repeated = [].concat(... new Array(100).fill([1, 2, 3]));
le ferait être un peu plus court.
J'aime cela parce que c'est une seule ligne qui est facile à lire et qui a du sens. Venant de python, cela me semble plus naturel.
Notez que vous pouvez également omettre le nouveau mot-clé .
@Jeto oui bon point même si j'avoue que cela me met irrationnellement mal à l'aise
Je me demande à quel point c'est efficace.
@MaxWaterman et si vous voulez faire quelque chose sur chaque élément d'un tableau, c'est intrinsèquement une opération en temps linéaire.
@Pointy bien sûr, mais est-ce linéaire? Cela dépend de la manière dont il est mis en œuvre. Il me semble que cela crée un tableau de pointeurs vers un nouveau tableau de longueur 3, puis il passe, encore une fois, pour l'aplatir en un tableau unidimensionnel. Comme je l'ai dit, je me demande si c'est plus intelligent que cela, ou pas. La solution Array.from () semble être plus évidemment une seule traversée (créer de la mémoire pour le tableau, puis l'assigner).
@MaxWaterman parcourant une liste un nombre fixe de fois est toujours O (n). Array.from () va également (en interne) faire un passage linéaire dans la liste.
@Pointy Ouais, ok, linéaire, assez juste - mais il semble passer deux fois par les (différents?) Tableaux, alors qu'il n'est pas clair pour moi que Array.from () passerait deux fois (d'où ma question), ou juste une fois. Je vous crois sur parole si vous pensez que la méthode Array.from () de Nina fait deux passes ... je ne sais pas pourquoi mais voilà - JavaScript est un drôle d'animal.
Notez que 100 n'est pas la «longueur du tableau de résultats». C'est le nombre de fois où le tableau fourni est "répété"
Essayez 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 à chaque itération, donc il peut créer un très grand tableau avec quelques itérations.
Cela ne génère pas la sortie souhaitée ou ne répond pas à l'exigence de «concis».
Vous pouvez créer un tableau avec la longueur souhaitée et mapper les valeurs.
var array = [1, 2, 3],
result = Array.from({ length: 3 * array.length }, (_, i) => array[i % array.length]);
console.log(result);
IMO, celui-ci est le plus efficace et semble correspondre à un malloc suivi d'une seule boucle sur les éléments du tableau. D'autres solutions semblent impliquer plusieurs boucles sur les éléments du tableau.
Utilisez Array.from ( ) pour créer un tableau avec une longueur du multiplicateur, où chaque élément contient le tableau d'origine. Utilisez ensuite Array.flat () pour convertir en un seul tableau:
const multiplyArray = (arr, length) =>
Array.from({ length }, () => arr).flat()
const arr = [1,2,3]
const arr2 = multiplyArray(arr, 3)
console.log(arr2)
Merci d'avoir attiré mon attention sur la méthode Array.from (), elle me sera utile à l'avenir.
Simple et clair:
var n=4; //times //put 100
var array = [1,2,3];
var newarray = [];
while(n--){ var newarray = newarray.concat(array); }
alert(newarray);
console.log (var); cela devrait probablement être console.log (array); , ne produirait toujours pas le résultat souhaité
@LucaKiebel Merci, corrigé.
Maintenant, cela fonctionne très bien ;-) En écrivant array avant de toujours doubler la taille du tableau.
Un moyen rapide est de joindre le tableau, de le répéter en utilisant string.repeat (), puis de le diviser et enfin d'utiliser ES6 Spreads
L'autre réponse est probablement meilleure. Ceci est juste un simple one-liner.
let arr = [1, 2, 3];
let res = [...arr.join("").repeat(3).split("").map(Number)];
console.log(res);
vous pouvez utiliser la méthode de chaîne
repeat, en utilisantjoinetsplitpour convertir le tableau vers et à partir d'un strong?@RobinZigmond serait problématique pour un tableau d'objets.
bon point @ Pointy, pour une raison quelconque, je pensais comme s'il s'agissait d'un tableau de chaînes, alors que l'OP parle clairement de nombres. (Cela fonctionnerait en quelque sorte pour les nombres. Contrairement aux objets!)
Array (100 * 3) .fill (). Map ((v, i) => [1,2,3] [i% 3])