C'è un modo migliore per eseguire un comando N volte in bash?

Occasionalmente eseguo una riga di comando bash come questa:

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

Per eseguire some_commandun numero di volte consecutive - 10 volte in questo caso.

Spesso some_commandè davvero una catena di comandi o una pipeline.

C'è un modo più conciso per farlo?

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

O come one-liner per coloro che vogliono copiare e incollare facilmente:

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

Utilizzando una costante:

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

Utilizzando una variabile (può includere espressioni matematiche):

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

Un altro modo semplice per hackerarlo:

seq 20 | xargs -Iz echo "Hi there"

esegui l'eco 20 volte.

Si noti che seq 20 | xargs -Iz echo "Hi there z"produrrebbe:

Ciao a tutti 1
Ciao a tutti 2
...

Se stai usando la shell zsh:

repeat 10 { echo 'Hello' }

Dove 10 è il numero di volte che il comando verrà ripetuto.

Usando GNU Parallel puoi fare:

parallel some_command ::: {1..1000}

Se non si desidera il numero come argomento ed eseguire solo un singolo lavoro alla volta:

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

Guarda il video introduttivo per una rapida introduzione: https://www.youtube.com/playlist?list=PL284C9FF2488BC6D1

Segui il tutorial ( http://www.gnu.org/software/parallel/parallel_tutorial.html ). La riga di comando ti ama per questo.

Una semplice funzione nel file di configurazione di bash ( ~/.bashrcspesso) potrebbe funzionare bene.

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

Chiamalo così.

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

xargsè veloce :

#!/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}

Su un moderno Linux a 64 bit, offre:

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

Questo ha senso, poiché il xargscomando è un singolo processo nativo che genera il /usr/bin/truecomando più volte, invece dei cicli fore whileche sono tutti interpretati in Bash. Naturalmente questo funziona solo per un singolo comando; se devi eseguire più comandi in ogni iterazione del ciclo, sarà altrettanto veloce, o forse più veloce, del passaggiosh -c 'command1; command2; ...' a xargs

L' -P1potrebbe anche essere modificato, per esempio,-P8 a deporre le uova 8 processi in parallelo per ottenere un altro grande spinta in termini di velocità.

Non so perché il parallelo GNU sia così lento. Avrei pensato che sarebbe paragonabile a Xargs.

Un'altra forma del tuo esempio:

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

Per uno, puoi avvolgerlo in una funzione:

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

Chiamalo come:

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

xargs e seq aiuteranno

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

la vista :

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

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

Nota il carattere di sottolineatura invece di usare una variabile.

Se stai bene eseguendolo periodicamente, puoi eseguire il comando seguente per eseguirlo ogni 1 secondo a tempo indeterminato. Puoi eseguire altri controlli personalizzati per eseguirlo n numero di volte.

watch -n 1 some_command

Se si desidera avere una conferma visiva delle modifiche, aggiungere --differencesprima dils comando.

Secondo la pagina man di OSX, c'è anche

L'opzione --cumulative rende l'evidenziazione "appiccicosa", presentando una visualizzazione corrente di tutte le posizioni che sono mai cambiate. L'opzione -t o --no-title disattiva l'intestazione che mostra l'intervallo, il comando e l'ora corrente nella parte superiore del display, nonché la seguente riga vuota.

La pagina man di Linux / Unix può essere trovata qui

Ho risolto con questo loop, in cui repeat è un numero intero che rappresenta il numero dei loop

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

Ancora un'altra risposta: utilizzare l'espansione dei parametri su parametri vuoti:

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

Testato su Centos 7 e MacOS.

Tutte le risposte esistenti sembrano richiedere bashe non funzionano con un BSD UNIX standard /bin/sh(ad es. kshSu OpenBSD ).

Il codice seguente dovrebbe funzionare su qualsiasi 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 po 'ingenuo ma questo è ciò che di solito ricordo dalla cima della mia testa:

for i in 1 2 3; do
  some commands
done

Molto simile alla risposta di @ joe-koberg. È meglio soprattutto se hai bisogno di molte ripetizioni, solo più difficile per me ricordare altre sintassi perché negli ultimi anni non sto usando bashmolto. Intendo non per lo scripting almeno.

Il file di 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

e l'uscita di seguito

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

Che ne dici della forma alternativa di formenzionata in (bashref) Looping Constructs ?

I loop sono probabilmente il modo giusto per farlo, ma ecco una divertente alternativa:

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

Se è necessario il numero di iterazione come parametro per la propria chiamata, utilizzare:

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

Modifica: è stato giustamente commentato che la soluzione fornita sopra funzionerebbe senza problemi solo con semplici esecuzioni di comandi (senza pipe, ecc.). puoi sempre usare ash -c per fare cose più complicate, ma non ne vale la pena.

Un altro metodo che uso in genere è la seguente funzione:

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

ora puoi chiamarlo come:

rep 3 10 echo iteration @

I primi due numeri indicano l'intervallo. Il @otterrà tradotta al numero di iterazioni. Ora puoi usarlo anche con le pipe:

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

con ti danno il numero di file nelle directory R1 .. R10.