Gibt es eine bessere Möglichkeit, einen Befehl N-mal in Bash auszuführen?

Ich führe gelegentlich eine Bash-Befehlszeile wie folgt aus:

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

some_commandMehrmals hintereinander ausführen - in diesem Fall zehnmal.

Oft some_commandist es wirklich eine Befehlskette oder eine Pipeline.

Gibt es eine präzisere Möglichkeit, dies zu tun?

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

Oder als Einzeiler für diejenigen, die einfach kopieren und einfügen möchten:

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

Verwenden einer Konstante:

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

Verwenden einer Variablen (kann mathematische Ausdrücke enthalten):

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

Ein weiterer einfacher Weg, um es zu hacken:

seq 20 | xargs -Iz echo "Hi there"

Echo 20 Mal ausführen.

Beachten Sie, dass seq 20 | xargs -Iz echo "Hi there z"Folgendes ausgegeben werden würde:

Hallo 1
Hallo 2
...

Wenn Sie die zsh-Shell verwenden:

repeat 10 { echo 'Hello' }

Dabei ist 10 die Häufigkeit, mit der der Befehl wiederholt wird.

Mit GNU Parallel können Sie Folgendes tun:

parallel some_command ::: {1..1000}

Wenn Sie die Nummer nicht als Argument verwenden und jeweils nur einen Job ausführen möchten:

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

Sehen Sie sich das Intro-Video für eine kurze Einführung an: https://www.youtube.com/playlist?list=PL284C9FF2488BC6D1

Gehen Sie durch das Tutorial ( http://www.gnu.org/software/parallel/parallel_tutorial.html ). Sie Kommandozeile mit Liebe Sie dafür.

Eine einfache Funktion in der Bash-Konfigurationsdatei ( ~/.bashrcoft) könnte gut funktionieren.

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

Nennen Sie es so.

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

xargsist schnell :

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

Auf einem modernen 64-Bit-Linux gibt es:

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

Dies ist sinnvoll, da der xargsBefehl ein einzelner nativer Prozess ist, der den /usr/bin/trueBefehl mehrmals erzeugt, anstelle der forund- whileSchleifen, die alle in Bash interpretiert werden. Dies funktioniert natürlich nur für einen einzelnen Befehl. Wenn Sie in jeder Iteration der Schleife mehrere Befehle ausführen müssen, ist diese genauso schnell oder möglicherweise schneller als die Übergabe sh -c 'command1; command2; ...'an xargs

Das -P1könnte auch geändert werden, -P8um beispielsweise 8 Prozesse parallel zu erzeugen, um einen weiteren großen Geschwindigkeitsschub zu erzielen.

Ich weiß nicht, warum GNU parallel so langsam ist. Ich hätte gedacht, es wäre vergleichbar mit Xargs.

Eine andere Form Ihres Beispiels:

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

Zum einen können Sie es in eine Funktion einschließen:

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

Nennen Sie es wie:

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

xargs und seq werden helfen

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

die Aussicht :

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

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

Beachten Sie den Unterstrich, anstatt eine Variable zu verwenden.

Wenn Sie dies regelmäßig tun, können Sie den folgenden Befehl ausführen, um es alle 1 Sekunde auf unbestimmte Zeit auszuführen. Sie können andere benutzerdefinierte Überprüfungen einrichten, um sie n-mal auszuführen.

watch -n 1 some_command

Wenn Sie eine visuelle Bestätigung der Änderungen wünschen, fügen Sie diese --differencesvor dem lsBefehl hinzu.

Laut der OSX-Manpage gibt es auch

Die Option --cumulative macht das Hervorheben "klebrig" und zeigt eine laufende Anzeige aller Positionen an, die sich jemals geändert haben. Mit der Option -t oder --no-title wird die Kopfzeile deaktiviert, in der das Intervall, der Befehl und die aktuelle Uhrzeit oben in der Anzeige sowie die folgende leere Zeile angezeigt werden.

Die Linux / Unix-Manpage finden Sie hier

Ich habe mit dieser Schleife gelöst, wobei Wiederholung eine Ganzzahl ist, die die Nummer der Schleifen darstellt

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

Noch eine Antwort: Verwenden Sie die Parametererweiterung für leere Parameter:

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

Getestet auf Centos 7 und MacOS.

Alle vorhandenen Antworten scheinen erforderlich zu sein bashund funktionieren nicht mit einem Standard-BSD-UNIX /bin/sh(z. B. kshunter OpenBSD ).

Der folgende Code sollte auf jedem BSD funktionieren:

$ 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
$

Ein bisschen naiv, aber das ist es, woran ich mich normalerweise auf Anhieb erinnere:

for i in 1 2 3; do
  some commands
done

Sehr ähnlich zu @ joe-kobergs Antwort. Seine ist besser, besonders wenn Sie viele Wiederholungen benötigen, nur schwieriger für mich, mich an andere Syntax zu erinnern, weil ich in den letzten Jahren nicht bashviel benutze . Ich meine zumindest nicht für Skripte.

Die Skriptdatei

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

echo "The argument is  arg: $1"

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

und die Ausgabe unten

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

Wie wäre es mit der alternativen Form der forin (bashref) Looping Constructs erwähnten ?

For-Loops sind wahrscheinlich der richtige Weg, aber hier ist eine unterhaltsame Alternative:

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

Wenn Sie die Iterationsnummer als Parameter für Ihren Aufruf benötigen, verwenden Sie:

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

Bearbeiten: Es wurde zu Recht kommentiert, dass die oben angegebene Lösung nur mit einfachen Befehlsläufen (keine Pipes usw.) reibungslos funktionieren würde. Sie können immer eine verwendensh -c , um kompliziertere Dinge zu tun, aber es lohnt sich nicht.

Eine andere Methode, die ich normalerweise verwende, ist die folgende Funktion:

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

Jetzt können Sie es nennen als:

rep 3 10 echo iteration @

Die ersten beiden Zahlen geben den Bereich an. Das @wird in die Iterationsnummer übersetzt. Jetzt können Sie dies auch mit Rohren verwenden:

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

mit geben Sie die Anzahl der Dateien in den Verzeichnissen R1 .. R10.