Existe uma maneira melhor de executar um comando N vezes no bash?

Ocasionalmente, executo uma linha de comando do bash como esta:

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

Para correr some_command várias vezes seguidas - 10 vezes neste caso.

Frequentemente some_command é realmente uma cadeia de comandos ou um pipeline.

Existe uma maneira mais concisa de fazer isso?

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

Ou como uma linha única para aqueles que desejam copiar e colar facilmente:

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

Usando uma constante:

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

Usando uma variável (pode incluir expressões matemáticas):

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

Outra maneira simples de hackear:

seq 20 | xargs -Iz echo "Hi there"

executar eco 20 vezes.

Observe que a seq 20 | xargs -Iz echo "Hi there z"saída seria:

Olá 1
Olá 2
...

Se você estiver usando o shell zsh:

repeat 10 { echo 'Hello' }

Onde 10 é o número de vezes que o comando será repetido.

Usando o GNU Parallel, você pode:

parallel some_command ::: {1..1000}

Se você não quiser o número como argumento e executar apenas um único trabalho por vez:

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

Assista ao vídeo de introdução para uma rápida introdução: https://www.youtube.com/playlist?list=PL284C9FF2488BC6D1

Percorra o tutorial ( http://www.gnu.org/software/parallel/parallel_tutorial.html ). Você comanda a linha com amor por isso.

Uma função simples no arquivo de configuração do bash ( ~/.bashrcgeralmente) pode funcionar bem.

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

Chame assim.

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

xargsé rápido :

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

Em um Linux moderno de 64 bits, fornece:

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

Isso faz sentido, pois o xargscomando é um único processo nativo que gera o /usr/bin/truecomando várias vezes, em vez dos loops fore whileque são interpretados no Bash. Claro que isso só funciona para um único comando; se você precisar executar vários comandos em cada iteração do loop, será tão rápido, ou talvez mais rápido, do que passarsh -c 'command1; command2; ...' para xargs

Também -P1pode ser alterado para, digamos,-P8 gerar 8 processos em paralelo para obter outro grande aumento de velocidade.

Não sei por que o GNU paralelo é tão lento. Eu teria pensado que seria comparável ao xargs.

Outra forma do seu exemplo:

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

Por um lado, você pode agrupá-lo em uma função:

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

Chame assim:

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

xargs e seq ajudarão

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

a vista :

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

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

Observe o sublinhado em vez de usar uma variável.

Se você fizer isso periodicamente, poderá executar o seguinte comando para executá-lo a cada 1 segundo indefinidamente. Você pode colocar outras verificações personalizadas para executá-lo n vezes.

watch -n 1 some_command

Se você deseja ter confirmação visual das alterações, acrescente --differencesantes do lscomando.

De acordo com a página do manual OSX, também há

A opção --cumulative torna o destaque "pegajoso", apresentando uma exibição contínua de todas as posições que já foram alteradas. A opção -t ou --no-title desativa o cabeçalho, mostrando o intervalo, o comando e a hora atual na parte superior da tela, bem como a seguinte linha em branco.

A página do manual Linux / Unix pode ser encontrada aqui

Eu resolvi com esse loop, onde repeat é um número inteiro que representa o número do loop

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

Outra resposta: use a expansão de parâmetros em parâmetros vazios:

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

Testado em Centos 7 e MacOS.

Todas as respostas existentes parecem exigir bashe não funcionam com um BSD UNIX padrão /bin/sh(por exemplo, kshno OpenBSD ).

O código abaixo deve funcionar em qualquer 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
$

Um pouco ingênuo, mas é disso que geralmente me lembro de cima:

for i in 1 2 3; do
  some commands
done

Muito semelhante à resposta de @ joe-koberg. O dele é melhor, especialmente se você precisar de muitas repetições, apenas é mais difícil me lembrar de outra sintaxe, porque nos últimos anos não estou usando bashmuito. Quero dizer, não pelo menos para scripts.

O arquivo de 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 a saída abaixo

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

E a forma alternativa formencionada em (bashref) Construções em loop ?

Pois loops são provavelmente o caminho certo para fazê-lo, mas aqui está uma alternativa divertida:

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

Se você precisar do número da iteração como parâmetro para sua chamada, use:

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

Edit: Foi comentado corretamente que a solução fornecida acima funcionaria sem problemas apenas com execuções simples de comando (sem pipes, etc.). você sempre pode usar umsh -c para fazer coisas mais complicadas, mas não vale a pena.

Outro método usado normalmente é a seguinte função:

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

agora você pode chamá-lo como:

rep 3 10 echo iteration @

Os dois primeiros números indicam o intervalo. O @será traduzido para o número da iteração. Agora você também pode usar isso com tubos:

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

com o número de arquivos nos diretórios R1 .. R10.