Czy jest lepszy sposób na uruchomienie polecenia N razy w bash?

Od czasu do czasu uruchamiam wiersz poleceń bash w następujący sposób:

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

Aby uruchomić some_commandkilka razy z rzędu - w tym przypadku 10 razy.

Często some_commandjest to łańcuch poleceń lub potok.

Czy jest na to bardziej zwięzły sposób?

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

Lub jako jedna linijka dla tych, którzy chcą łatwo kopiować i wklejać:

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

Używając stałej:

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

Używanie zmiennej (może obejmować wyrażenia matematyczne):

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

Kolejny prosty sposób na włamanie:

seq 20 | xargs -Iz echo "Hi there"

uruchom echo 20 razy.

Zauważ, seq 20 | xargs -Iz echo "Hi there z"że wyświetli się:

Cześć 1
Cześć 2
...

Jeśli używasz powłoki zsh:

repeat 10 { echo 'Hello' }

Gdzie 10 to liczba powtórzeń polecenia.

Korzystając z GNU Parallel możesz:

parallel some_command ::: {1..1000}

Jeśli nie chcesz, aby liczba była argumentem, i uruchamiaj tylko jedno zadanie na raz:

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

Obejrzyj film wprowadzający, aby zapoznać się z krótkim wprowadzeniem: https://www.youtube.com/playlist?list=PL284C9FF2488BC6D1

Przejrzyj samouczek ( http://www.gnu.org/software/parallel/parallel_tutorial.html ). Wiersz poleceń z miłością za to.

Prosta funkcja w pliku konfiguracyjnym bash ( ~/.bashrcczęsto) może działać dobrze.

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

Nazwij to tak.

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

xargsjest szybki :

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

W nowoczesnym 64-bitowym systemie Linux zapewnia:

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

Ma to sens, ponieważ xargspolecenie jest pojedynczym rodzimym procesem, który odradza /usr/bin/truepolecenie wiele razy, zamiast pętli fori whileinterpretowanych w Bash. Oczywiście działa to tylko dla jednego polecenia; jeśli musisz wykonać wiele poleceń w każdej iteracji w pętli, będzie to tak samo szybkie, a może szybsze, niż przekazywanie sh -c 'command1; command2; ...'do xargs

Można -P1to również zmienić, powiedzmy, -P8aby spawnować 8 procesów równolegle, aby uzyskać kolejny duży wzrost prędkości.

Nie wiem, dlaczego GNU równolegle jest tak wolne. Myślałem, że będzie to porównywalne z xargs.

Inna forma Twojego przykładu:

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

Po pierwsze możesz zawinąć to w funkcję:

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

Nazwij to tak:

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

xargs i seq pomogą

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

widok :

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

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

Zwróć uwagę na podkreślenie zamiast używania zmiennej.

Jeśli możesz robić to okresowo, możesz uruchomić następującą komendę, aby uruchomić ją co 1 sekundę w nieskończoność. Możesz wprowadzić inne niestandardowe kontrole, aby uruchomić je n razy.

watch -n 1 some_command

Jeśli chcesz mieć wizualne potwierdzenie zmian, dołącz --differencesprzed lspoleceniem.

Według strony podręcznika OSX jest też

Opcja --cumulative sprawia, że ​​podświetlanie jest „lepkie”, co pokazuje bieżące wyświetlanie wszystkich pozycji, które kiedykolwiek się zmieniły. Opcja -t lub --no-title wyłącza nagłówek pokazujący interwał, polecenie i aktualny czas w górnej części wyświetlacza, a także następujący pusty wiersz.

Strona podręcznika Linux / Unix można znaleźć tutaj

Rozwiązałem tę pętlę, w której powtórzenie jest liczbą całkowitą reprezentującą liczbę pętli

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

Jeszcze inna odpowiedź: użyj rozwinięcia parametru dla pustych parametrów:

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

Testowane na Centos 7 i MacOS.

Wszystkie istniejące odpowiedzi wydają się wymagać bashi nie działają ze standardowym BSD UNIX /bin/sh(np. W kshOpenBSD ).

Poniższy kod powinien działać na każdym 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
$

Trochę naiwne, ale tak zwykle pamiętam z głowy:

for i in 1 2 3; do
  some commands
done

Bardzo podobny do odpowiedzi @ Joe-Koberg. Jego jest lepszy, zwłaszcza jeśli potrzebujesz wielu powtórzeń, tylko trudniej mi zapamiętać inną składnię, ponieważ w ostatnich latach nie używam bashdużo. Mam na myśli, że przynajmniej nie do pisania skryptów.

Plik skryptu

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

echo "The argument is  arg: $1"

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

i wynik poniżej

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

Co powiesz na alternatywną formę forwymienioną w (bashref) Looping Constructs ?

Pętle są prawdopodobnie właściwym sposobem na zrobienie tego, ale jest fajna alternatywa:

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

Jeśli potrzebujesz numeru iteracji jako parametru do wywołania, użyj:

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

Edytować: słusznie skomentowano, że powyższe rozwiązanie będzie działać płynnie tylko przy prostych uruchomieniach poleceń (bez potoków itp.). zawsze możesz użyćsh -c bardziej skomplikowanych rzeczy, ale nie warto.

Inną metodą, której zwykle używam, jest następująca funkcja:

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

teraz możesz to nazwać:

rep 3 10 echo iteration @

Pierwsze dwie liczby określają zakres. @Będą tłumaczone na liczbę iteracji. Teraz możesz używać tego również z rurami:

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

z poda liczbę plików w katalogach R1 .. R10.