¿Hay una mejor manera de ejecutar un comando N veces en bash?

De vez en cuando ejecuto una línea de comando bash como esta:

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

Para ejecutar some_commandvarias veces seguidas, 10 veces en este caso.

A menudo some_commandes realmente una cadena de comandos o una tubería.

¿Hay una manera más concisa de hacer esto?

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

O como una línea para aquellos que quieren copiar y pegar fácilmente:

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

Usando una constante:

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

Usando una variable (puede incluir expresiones matemáticas):

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

Otra forma simple de hackearlo:

seq 20 | xargs -Iz echo "Hi there"

ejecutar echo 20 veces.

Observe que eso seq 20 | xargs -Iz echo "Hi there z"generaría:

Hola 1
Hola 2
...

Si está utilizando el shell zsh:

repeat 10 { echo 'Hello' }

Donde 10 es el número de veces que se repetirá el comando.

Usando GNU Parallel puedes hacer:

parallel some_command ::: {1..1000}

Si no desea el número como argumento y solo ejecuta un trabajo a la vez:

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

Mire el video de introducción para una introducción rápida: https://www.youtube.com/playlist?list=PL284C9FF2488BC6D1

Recorra el tutorial ( http://www.gnu.org/software/parallel/parallel_tutorial.html ). Usted ordena línea con amor por ello.

Una función simple en el archivo de configuración bash (a ~/.bashrcmenudo) podría funcionar bien.

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

Llámalo así.

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

xargses 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}

En un moderno Linux de 64 bits, da:

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

Esto tiene sentido, ya que el xargscomando es un proceso nativo único que genera el /usr/bin/truecomando varias veces, en lugar de los bucles fory whileque se interpretan en Bash. Por supuesto, esto solo funciona para un solo comando; Si necesita hacer múltiples comandos en cada iteración del ciclo, será tan rápido, o tal vez más rápido, que pasar sh -c 'command1; command2; ...'a xargs

También -P1podría cambiarse, por ejemplo, -P8para generar 8 procesos en paralelo para obtener otro gran impulso en la velocidad.

No sé por qué GNU paralelo es tan lento. Pensé que sería comparable a los xargs.

Otra forma de tu ejemplo:

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

Por un lado, puede envolverlo en una función:

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

Llámalo como:

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

xargs y seq ayudarán

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   

Tenga en cuenta el guión bajo en lugar de usar una variable.

Si está bien haciéndolo periódicamente, puede ejecutar el siguiente comando para ejecutarlo cada 1 segundo indefinidamente. Puede colocar otras comprobaciones personalizadas para ejecutarlo n varias veces.

watch -n 1 some_command

Si desea tener una confirmación visual de los cambios, agregue --differencesantes de lals comando.

Según la página del manual de OSX, también hay

La opción --cumulativa hace que el resaltado sea "pegajoso", presentando una visualización continua de todas las posiciones que alguna vez han cambiado. La opción -t o --no-title desactiva el encabezado que muestra el intervalo, el comando y la hora actual en la parte superior de la pantalla, así como la siguiente línea en blanco.

La página de manual de Linux / Unix se puede encontrar aquí

Resolví con este bucle, donde repetir es un número entero que representa el número del bucle.

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

Otra respuesta más: use la expansión de parámetros en parámetros vacíos:

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

Probado en Centos 7 y MacOS.

Parece que todas las respuestas existentes requieren bashy no funcionan con un BSD UNIX estándar /bin/sh(por ejemplo, kshen OpenBSD ).

El siguiente código debería funcionar en cualquier 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 poco ingenuo, pero esto es lo que generalmente recuerdo de la cabeza:

for i in 1 2 3; do
  some commands
done

Muy similar a la respuesta de @ joe-koberg. La suya es mejor, especialmente si necesita muchas repeticiones, pero es más difícil para mí recordar otra sintaxis porque en los últimos años no uso bashmucho. No me refiero a las secuencias de comandos al menos.

El archivo 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

y la salida a continuación

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

¿Qué tal la forma alternativa de las construcciones de buclefor mencionadas (bashref) ?

Los bucles son probablemente la forma correcta de hacerlo, pero aquí hay una alternativa divertida:

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

Si necesita el número de iteración como parámetro para su invocación, use:

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

Editar: se comentó correctamente que la solución dada anteriormente funcionaría sin problemas solo con ejecuciones de comandos simples (sin tuberías, etc.). siempre puedes usar a sh -cpara hacer cosas más complicadas, pero no vale la pena.

Otro método que uso típicamente es la siguiente función:

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

ahora puedes llamarlo como:

rep 3 10 echo iteration @

Los primeros dos números dan el rango. El @será traducido al número de iteración. Ahora también puedes usar esto con tuberías:

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

con darle el número de archivos en los directorios R1 .. R10.