Existe-t-il une meilleure façon d'exécuter une commande N fois en bash?

J'exécute parfois une ligne de commande bash comme celle-ci:

n=0; while [[ $n -lt 10 ]]; do some_command; n=$((n+1)); done

Pour exécuter some_commandplusieurs fois de suite - 10 fois dans ce cas.

Il some_commands'agit souvent d' une chaîne de commandes ou d'un pipeline.

Existe-t-il une manière plus concise de procéder?

for run in {1..10}
do
  command
done

Ou comme une ligne pour ceux qui veulent copier et coller facilement:

for run in {1..10}; do command; done

En utilisant une constante:

for ((n=0;n<10;n++)); do some_command; done

Utilisation d'une variable (peut inclure des expressions mathématiques):

x=10; for ((n=0; n < (x / 2); n++)); do some_command; done

Un autre moyen simple de le pirater:

seq 20 | xargs -Iz echo "Hi there"

exécuter l'écho 20 fois.

Notez que cela seq 20 | xargs -Iz echo "Hi there z"produirait:

Salut à 1
Salut à 2
...

Si vous utilisez le shell zsh:

repeat 10 { echo 'Hello' }

Où 10 est le nombre de fois que la commande sera répétée.

En utilisant GNU Parallel, vous pouvez faire:

parallel some_command ::: {1..1000}

Si vous ne voulez pas le nombre comme argument et que vous n'exécutez qu'un seul travail à la fois:

parallel -j1 -N0 some_command ::: {1..1000}

Regardez la vidéo d'introduction pour une introduction rapide: https://www.youtube.com/playlist?list=PL284C9FF2488BC6D1

Parcourez le didacticiel ( http://www.gnu.org/software/parallel/parallel_tutorial.html ). Vous commandez en ligne avec amour pour vous.

Une fonction simple dans le fichier de configuration bash ( ~/.bashrcsouvent) pourrait bien fonctionner.

function runx() {
  for ((n=0;n<$1;n++))
    do ${*:2}
  done
}

Appelez ça comme ça.

$ runx 3 echo 'Hello world'
Hello world
Hello world
Hello world

xargsest rapide :

#!/usr/bin/bash
echo "while loop:"
n=0; time while (( n++ < 10000 )); do /usr/bin/true ; done

echo -e "\nfor loop:"
time for ((n=0;n<10000;n++)); do /usr/bin/true ; done

echo -e "\nseq,xargs:"
time seq 10000 | xargs -I{} -P1 -n1 /usr/bin/true

echo -e "\nyes,xargs:"
time yes x | head -n10000 |  xargs -I{} -P1 -n1 /usr/bin/true

echo -e "\nparallel:"
time parallel --will-cite -j1 -N0 /usr/bin/true ::: {1..10000}

Sur un Linux 64 bits moderne, donne:

while loop:

real    0m2.282s
user    0m0.177s
sys     0m0.413s

for loop:

real    0m2.559s
user    0m0.393s
sys     0m0.500s

seq,xargs:

real    0m1.728s
user    0m0.013s
sys     0m0.217s

yes,xargs:

real    0m1.723s
user    0m0.013s
sys     0m0.223s

parallel:

real    0m26.271s
user    0m4.943s
sys     0m3.533s

Cela a du sens, car la xargscommande est un processus natif unique qui génère la /usr/bin/truecommande plusieurs fois, au lieu des boucles foret whilequi sont toutes interprétées dans Bash. Bien sûr, cela ne fonctionne que pour une seule commande; si vous avez besoin de faire plusieurs commandes à chaque itération de la boucle, ce sera tout aussi rapide, ou peut-être plus rapide, que de passer sh -c 'command1; command2; ...'à xargs

Le -P1pourrait également être modifié pour, par exemple, -P8engendrer 8 processus en parallèle pour obtenir un autre coup de pouce de vitesse.

Je ne sais pas pourquoi le parallèle GNU est si lent. J'aurais pensé que ce serait comparable aux xargs.

Une autre forme de votre exemple:

n=0; while (( n++ < 10 )); do some_command; done

D'une part, vous pouvez le résumer dans une fonction:

function manytimes {
    n=0
    times=$1
    shift
    while [[ $n -lt $times ]]; do
        $@
        n=$((n+1))
    done
}

Appelez ça comme:

$ manytimes 3 echo "test" | tr 'e' 'E'
tEst
tEst
tEst

xargs et seq aideront

function __run_times { seq 1 $1| { shift; xargs -i -- "$@"; } }

la vue :

abon@abon:~$ __run_times 3  echo hello world
hello world
hello world
hello world

for _ in {1..10}; do command; done   

Notez le trait de soulignement au lieu d'utiliser une variable.

Si vous êtes d'accord pour le faire périodiquement, vous pouvez exécuter la commande suivante pour l'exécuter toutes les 1 s indéfiniment. Vous pouvez mettre en place d'autres contrôles personnalisés pour l'exécuter n nombre de fois.

watch -n 1 some_command

Si vous souhaitez avoir une confirmation visuelle des modifications, ajoutez-les --differencesavant la lscommande.

Selon la page de manuel OSX, il y a aussi

L'option --cumulative rend la surbrillance "collante", présentant un affichage en cours de toutes les positions qui ont changé. L'option -t ou --no-title désactive l'en-tête affichant l'intervalle, la commande et l'heure actuelle en haut de l'écran, ainsi que la ligne vierge suivante.

La page de manuel Linux / Unix peut être trouvée ici

J'ai résolu avec cette boucle, où la répétition est un entier qui représente le nombre de boucles

repeat=10
for n in $(seq $repeat); 
    do
        command1
        command2
    done

Encore une autre réponse: utilisez l'expansion des paramètres sur les paramètres vides:

# calls curl 4 times 
curl -s -w "\n" -X GET "http:{,,,}//www.google.com"

Testé sur Centos 7 et MacOS.

Toutes les réponses existantes semblent nécessiter bashet ne fonctionnent pas avec un BSD UNIX standard /bin/sh(par exemple, kshsur OpenBSD ).

Le code ci-dessous devrait fonctionner sur n'importe quel BSD:

$ echo {1..4}
{1..4}
$ seq 4
sh: seq: not found
$ for i in $(jot 4); do echo e$i; done
e1
e2
e3
e4
$

Un peu naïf mais c'est ce dont je me souviens habituellement du haut de ma tête:

for i in 1 2 3; do
  some commands
done

Très similaire à la réponse de @ joe-koberg. La sienne est meilleure, surtout si vous avez besoin de nombreuses répétitions, juste plus difficile pour moi de me souvenir d'une autre syntaxe car ces dernières années, je n'utilise pas bashbeaucoup. Je veux dire pas pour les scripts au moins.

Le fichier script

bash-3.2$ cat test.sh 
#!/bin/bash

echo "The argument is  arg: $1"

for ((n=0;n<$1;n++));
do
  echo "Hi"
done

et la sortie ci-dessous

bash-3.2$  ./test.sh 3
The argument is  arg: 3
Hi
Hi
Hi
bash-3.2$

Que diriez - vous de la forme alternative de formentionné dans (bashref) Looping Constructs ?

Les boucles sont probablement la bonne façon de le faire, mais voici une alternative amusante:

echo -e {1..10}"\n" |xargs -n1 some_command

Si vous avez besoin du numéro d'itération comme paramètre pour votre appel, utilisez:

echo -e {1..10}"\n" |xargs -I@ echo now I am running iteration @

Edit: Il a été à juste titre commenté que la solution donnée ci-dessus ne fonctionnerait correctement qu'avec des exécutions de commandes simples (pas de tuyaux, etc.). vous pouvez toujours utiliser unsh -c pour faire des choses plus compliquées, mais cela n'en vaut pas la peine.

Une autre méthode que j'utilise généralement est la fonction suivante:

rep() { s=$1;shift;e=$1;shift; for x in `seq $s $e`; do c=${@//@/$x};sh -c "$c"; done;}

vous pouvez maintenant l'appeler comme:

rep 3 10 echo iteration @

Les deux premiers chiffres donnent la plage. Le @sera traduit au numéro d'itération. Maintenant, vous pouvez également l'utiliser avec des tuyaux:

rep 1 10 "ls R@/|wc -l"

vous donne le nombre de fichiers dans les répertoires R1 .. R10.