it-swarm.com.de

Wiederholen Sie einen Unix-Befehl alle x Sekunden für immer

Es gibt einen integrierten Unix-Befehl repeat, dessen erstes Argument die Häufigkeit ist, mit der ein Befehl wiederholt wird, wobei der Befehl (mit beliebigen Argumenten) durch die verbleibenden Argumente für repeat angegeben wird.

Zum Beispiel,

% repeat 100 echo "I will not automate this punishment."

wird die angegebene Zeichenfolge 100 Mal wiederholen und dann anhalten.

Ich hätte gerne einen ähnlichen Befehl - nennen wir ihn forever -, der ähnlich funktioniert, außer dass das erste Argument die Anzahl der Sekunden ist, die zwischen den Wiederholungen angehalten werden sollen, und die für immer wiederholt werden. Zum Beispiel,

% forever 5 echo "This will get echoed every 5 seconds forever and ever."

Ich dachte, ich würde fragen, ob so etwas existiert, bevor ich es schreibe. Ich weiß, es ist wie ein zweizeiliges Perl- oder Python -Skript, aber vielleicht gibt es eine Standardmethode, um dies zu tun. Wenn nicht, können Sie eine Lösung in Ihrer bevorzugten Skriptsprache veröffentlichen.

PS: Vielleicht wäre ein besserer Weg, dies zu tun, repeat zu verallgemeinern, um sowohl die Anzahl der Wiederholungen (wobei -1 bedeutet unendlich) als auch die Anzahl der Sekunden, die zwischen den Wiederholungen zu schlafen sind, zu nehmen. Die obigen Beispiele würden dann werden:

% repeat 100 0 echo "I will not automate this punishment."
% repeat -1 5 echo "This will get echoed every 5 seconds forever."
497
dreeves

Versuchen Sie den Befehl watch.

Usage: watch [-dhntv] [--differences[=cumulative]] [--help] [--interval=<n>] 
             [--no-title] [--version] <command>`

Damit:

watch -n1  command

führt den Befehl jede Sekunde aus (technisch gesehen jede Sekunde plus die Zeit, die command benötigt, um als watch ausgeführt zu werden (mindestens procps und busybox Implementierungen) schläft nur eine Sekunde zwischen zwei Durchläufen von command) für immer.

Wenn Sie den Befehl an exec anstelle von sh -c Übergeben möchten, verwenden Sie die Option -x:

watch -n1 -x command

Unter macOS können Sie watch von Mac Ports :

port install watch

Oder Sie können es von Homebrew bekommen:

brew install watch
637
Gregor Brandt

Bash

while + sleep:

while true
do 
    echo "Hi"
    sleep 1
done

Hier ist das Gleiche wie bei einem Einzeiler (aus den Kommentaren unten):

while sleep 1; do echo "Hi"; done

Verwendet ; zum Trennen von Befehlen und verwendet sleep 1 für den while Test, da immer true zurückgegeben wird. Sie können weitere Befehle in die Schleife einfügen - trennen Sie sie einfach mit ;

255
pope

Dies ist nur eine kürzere Version anderer while+sleep antwortet, wenn Sie diese Art von Aufgaben häufig als Ihre tägliche Routine ausführen, erspart Ihnen dies unnötiges Drücken von Tasten, und wenn Ihre Befehlszeile länger zu verstehen beginnt, ist dies etwas einfacher. Aber dieser beginnt zuerst mit dem Schlafen.

Dies ist im Allgemeinen nützlich, wenn Sie etwas folgen müssen, das eine einzeilige Ausgabe wie Maschinenlast hat:

while sleep 1; do uptime; done
73
Bekir Dogan

Ein Problem, das alle bisher veröffentlichten Antworten haben, ist, dass die Zeit, in der der Befehl ausgeführt wird, driften kann. Zum Beispiel, wenn Sie ein sleep 10 zwischen Befehlen, und der Befehl dauert 2 Sekunden, dann wird er alle 12 Sekunden ausgeführt; Wenn die Ausführung unterschiedlich lange dauert, kann die Laufzeit langfristig unvorhersehbar sein.

Dies könnte genau das sein, was Sie wollen; Wenn ja, verwenden Sie eine der anderen Lösungen oder verwenden Sie diese, vereinfachen Sie jedoch den Aufruf von sleep.

Bei einer Auflösung von einer Minute werden Cron-Jobs zum angegebenen Zeitpunkt ausgeführt, unabhängig davon, wie lange jeder Befehl dauert. (Tatsächlich wird ein neuer Cron-Job gestartet, auch wenn der vorherige noch ausgeführt wird.)

Hier ist ein einfaches Perl-Skript, das bis zum nächsten Intervall schläft. So kann der Befehl beispielsweise mit einem Intervall von 10 Sekunden um 12:34:00, 12:34:10, 12:34:20 usw. ausgeführt werden, selbst wenn der Der Befehl selbst dauert einige Sekunden. Wenn der Befehl länger als interval Sekunden ausgeführt wird, wird das nächste Intervall übersprungen (im Gegensatz zu cron). Das Intervall wird relativ zur Epoche berechnet, sodass um Mitternacht UTC ein Intervall von 86400 Sekunden (1 Tag) ausgeführt wird.

#!/usr/bin/Perl

use strict;
use warnings;

if (scalar @ARGV < 2) {
    die "Usage: $0 seconds command [args...]\n";
}

$| = 1;  # Ensure output appears

my($interval, @command) = @ARGV;

# print ">>> interval=$interval command=(@command)\n";

while (1) {
    print "sleep ", $interval - time % $interval, "\n";
    sleep $interval - time % $interval;
    system @command; # TODO: Handle errors (how?)
}
46
Keith Thompson

Ich denke, alle Antworten hier sind entweder zu kompliziert oder beantworten stattdessen eine andere Frage:

  • "So führen Sie ein Programm wiederholt aus, sodass zwischen dem Ende des Programms und dem nächsten Start eine Verzögerung von X Sekunden liegt".

Die eigentliche Frage war:

  • "So führen Sie alle X Sekunden ein Programm aus"

Dies sind zwei sehr unterschiedliche Dinge, wenn der Befehl einige Zeit in Anspruch nimmt.

Nehmen Sie zum Beispiel das Skript foo.sh (Stellen Sie sich vor, dies ist ein Programm, dessen Fertigstellung einige Sekunden dauert).

#!/bin/bash
# foo.sh
echo `date +"%H:%M:%S"` >> output.txt;
sleep 2.5;
# ---

Sie möchten dies jede Sekunde ausführen, und die meisten schlagen watch -n1 ./foo.sh Oder while sleep 1; do ./foo.sh; done Vor. Dies ergibt jedoch die Ausgabe:

15:21:20
15:21:23
15:21:27
15:21:30
15:21:34

Welches nicht genau jede Sekunde ausgeführt wird. Selbst mit dem Flag -p Ist das Ergebnis dasselbe, wie auf der Seite man watch Vorgeschlagen wird.

Eine einfache Möglichkeit, die gewünschte Aufgabe zu erledigen, besteht darin, den Befehl im Hintergrund auszuführen. Mit anderen Worten:

while sleep 1; do (./foo.sh &) ; done

nd das ist alles was dazu gehört.

Sie könnten es alle 500 ms mit sleep 0.5 Ausführen, oder was haben Sie.

33
swalog

In bash:

bash -c 'while [ 0 ]; do echo "I will not automate this punishment in absurdum."; done'

(echo kann durch einen beliebigen Befehl ersetzt werden ...

Oder in Perl:

Perl -e 'for (;1;) {print "I will not automate this punishment in absurdum.\n"}'

Wo print "I will not automate this punishment in absurdum.\n" könnte durch einen beliebigen Befehl ersetzt werden, der von Backticks (`) umgeben ist.

Fügen Sie für eine Pause eine sleep - Anweisung in die for-Schleife ein:

bash -c 'while [ 0 ]; do echo "I will not automate this punishment in absurdum."; sleep 1; done'

und

Perl -e 'for (;1;) {print "I will not automate this punishment in absurdum.\n"; sleep 1}'
17
Tooony

Letzte Bash> = 4.2 unter aktueller Linux-Kernel-basierter Antwort.

Um die Ausführungszeit zu begrenzen, gibt es keine Gabeln ! Es werden nur eingebaute verwendet.

Dafür verwende ich die integrierte Funktion read anstelle von sleep. Leider funktioniert dies nicht mit notty Sitzungen.

Quick bash Funktion "repeat" wie gewünscht:

repeat () {
   local repeat_times=$1 repeat_delay=$2 repeat_foo repeat_sleep
   read -t .0001 repeat_foo
   if [ $? = 1 ] ;then
       repeat_sleep() { sleep $1 ;}
   else
       repeat_sleep() { read -t $1 repeat_foo; }
   fi
   shift 2
   while ((repeat_times)); do
        ((repeat_times=repeat_times>0?repeat_times-1:repeat_times))
        "${@}"
        ((repeat_times))&& ((10#${repeat_delay//.})) &&
            repeat_sleep $repeat_delay
   done
}

Kleiner Test mit zitierten Zeichenfolgen:

repeat 3 0 printf "Now: %(%T)T, Hello %s.\n" -1 Guy
Now: 15:13:43, Hello Guy.
Now: 15:13:43, Hello Guy.
Now: 15:13:43, Hello Guy.

repeat -1 .5 printf "Now: %(%T)T, Hello %s.\n" -1 Guy
Now: 15:14:14, Hello Guy.
Now: 15:14:14, Hello Guy.
Now: 15:14:15, Hello Guy.
Now: 15:14:15, Hello Guy.
Now: 15:14:16, Hello Guy.
Now: 15:14:16, Hello Guy.
Now: 15:14:17, Hello Guy.
Now: 15:14:17, Hello Guy.
Now: 15:14:18, Hello Guy.
Now: 15:14:18, Hello Guy.
^C

Abhängig von Granularität und Dauer des übermittelten Befehls ...

Unter den neuesten Linux-Kerneln gibt es ein procfile /proc/timer_list mit Zeitinformationen in Nanosekunden.

Wenn Sie einen Befehl genau einmal pro Sekunde ausführen möchten, muss Ihr Befehl in weniger als einer Sekunde enden! Und von dort müssen Sie sleep nur die Rest der aktuellen Sekunde.

Wenn die Verzögerung wichtiger ist und Ihr Befehl keine nennenswerte Zeit benötigt, können Sie:

command=(echo 'Hello world.')
delay=10
while :;do
    printf -v now "%(%s)T" -1
    read -t $(( delay-(now%delay) )) foo
    ${command[@]}
  done.

Wenn Sie jedoch eine feinere Granularität erzielen möchten, müssen Sie:

Verwenden Sie Nanosekunden-Informationen, um bis zum Beginn einer Sekunde zu warten ...

Dafür habe ich eine kleine Bash-Funktion geschrieben:

# bash source file for nano wait-until-next-second

mapfile  </proc/timer_list _timer_list
for ((_i=0;_i<${#_timer_list[@]};_i++));do
    ((_c+=${#_timer_list[_i]}))
    [[ ${_timer_list[_i]} =~ ^now ]] && TIMER_LIST_READ=$_c
    [[ ${_timer_list[_i]} =~ offset:.*[1-9] ]] && \
        TIMER_LIST_OFFSET=${_timer_list[_i]//[a-z.: ]} && \
        break
done
unset _i _timer_list _c
readonly TIMER_LIST_OFFSET TIMER_LIST_READ
waitNextSecondHires() {
    local nsnow nsslp
    read -N$TIMER_LIST_READ nsnow </proc/timer_list
    nsnow=${nsnow%% nsecs*}
    nsnow=$((${nsnow##* }+TIMER_LIST_OFFSET))
    nsslp=$((2000000000-10#${nsnow:${#nsnow}-9}))
    read -t .${nsslp:1} foo
}

Nach der Beschaffung können Sie:

command=(echo 'Hello world.')
while :;do
    waitNextSecondHires
    ${command[@]}
  done.

lauf ${command[@]} direkt in der Kommandozeile, als zu vergleichen mit

command=(eval "echo 'Hello world.';sleep .3")
while :;do
    waitNextSecondHires
    ${command[@]}
  done.

dies muss genau das gleiche Ergebnis liefern.

Hires bash Funktion "repeat" wie gewünscht:

Sie könnten dies beschaffen:

mapfile  </proc/timer_list _timer_list
for ((_i=0;_i<${#_timer_list[@]};_i++));do
    ((_c+=${#_timer_list[_i]}))
    [[ ${_timer_list[_i]} =~ ^now ]] && TIMER_LIST_READ=$_c
    [[ ${_timer_list[_i]} =~ offset:.*[1-9] ]] && \
        TIMER_LIST_OFFSET=${_timer_list[_i]//[a-z.: ]} && \
        break
done
unset _i _timer_list _c
readonly TIMER_LIST_OFFSET TIMER_LIST_READ

repeat_hires () {
    local repeat_times=$1 repeat_delay=$2 repeat_foo repeat_sleep repeat_count
    read -t .0001 repeat_foo
    if [ $? = 1 ] ;then
        repeat_sleep() { sleep $1 ;}
    else
        repeat_sleep() { read -t $1 repeat_foo; }
    fi
    shift 2
    printf -v repeat_delay "%.9f" $repeat_delay
    repeat_delay=${repeat_delay//.}
    read -N$TIMER_LIST_READ nsnow </proc/timer_list
    nsnow=${nsnow%% nsec*}
    started=${nsnow##* }
    while ((repeat_times)); do
        ((repeat_times=repeat_times>0?repeat_times-1:repeat_times))
        "${@}"
        ((repeat_times)) && ((10#$repeat_delay)) && {
            read -N$TIMER_LIST_READ nsnow </proc/timer_list
            nsnow=${nsnow%% nsec*}
            nsnow=${nsnow##* }
            (( (nsnow - started) / 10#$repeat_delay - repeat_count++ )) &&
                printf >&2 "WARNING: Command '%s' too long for %f delay.\n" \
                           "${*}" ${repeat_delay:0:${#repeat_delay}-9
                           }.${repeat_delay:${#repeat_delay}-9}
            printf -v sleep "%010d" $((
                10#$repeat_delay - ( ( nsnow - started ) % 10#$repeat_delay ) ))
            repeat_sleep ${sleep:0:${#sleep}-9}.${sleep:${#sleep}-9}
        }
    done
}

Dann probieren Sie es aus:

time repeat_hires 21 .05 sh -c 'date +%s.%N;sleep .01'
1480867565.152022457
1480867565.201249108
1480867565.251333284
1480867565.301224905
1480867565.351236725
1480867565.400930482
1480867565.451207075
1480867565.501212329
1480867565.550927738
1480867565.601199721
1480867565.651500618
1480867565.700889792
1480867565.750963074
1480867565.800987954
1480867565.853671458
1480867565.901232296
1480867565.951171898
1480867566.000917199
1480867566.050942638
1480867566.101171249
1480867566.150913407

real    0m1.013s
user    0m0.000s
sys     0m0.016s

time repeat_hires 3 .05 sh -c 'date +%s.%N;sleep .05'
1480867635.380561067
WARNING: Command 'sh -c date +%s.%N;sleep .05' too long for 0.050000 delay.
1480867635.486503367
WARNING: Command 'sh -c date +%s.%N;sleep .05' too long for 0.050000 delay.
1480867635.582332617

real    0m0.257s
user    0m0.000s
sys     0m0.004s
10
F. Hauri

Bash und einige seiner verwandten Muscheln haben die bequeme (( ... )) Notation, in der arithmetische Ausdrücke ausgewertet werden können.

Als Antwort auf Ihre dritte Herausforderung, bei der sowohl die Anzahl der Wiederholungen als auch die Verzögerung zwischen den einzelnen Wiederholungen konfigurierbar sein sollten, haben Sie folgende Möglichkeiten:

repeat=10
delay=1

i=0
while (( i++ < repeat )); do
  echo Repetition $i
  sleep $delay
done

Diese Antwort leidet auch unter der Zeitverschiebung, die in Keiths Antwort behandelt wird.

4
Thor

Wenn Sie nicht beabsichtigen, eine Meldung auf Ihrem Bildschirm anzuzeigen, und wenn Sie es sich leisten könnten, den Auftrag in Minuten zu wiederholen, wäre crontab möglicherweise Ihr bestes Werkzeug. Wenn Sie beispielsweise Ihren Befehl jede Minute ausführen möchten, schreiben Sie Folgendes in Ihre crontab -Datei:

* * * * * my_precious_command

Weitere Beispiele finden Sie im Tutorial. Sie können die Timings auch einfach mit Crontab Code Generator einstellen.

4
Barun

Perl

#!/usr/bin/env Perl
# First argument is number of seconds to sleep between repeats, remaining
# arguments give the command to repeat forever.

$sleep = shift;
$cmd = join(' ', @ARGV);

while(1) {
  system($cmd);
  sleep($sleep); 
}
4
dreeves

Möchtest du das ausprobieren (Bash)?

forever ()   {
    TIMES=shift;
    SLEEP=shift;
    if [ "$TIMES" = "-1" ]; then  
        while true;
        do 
            [email protected]
            sleep $SLEEP
        done
    else
        repeat "$TIMES" [email protected] 
    fi; }
4
Gregg Lind

Wie von gbrandt erwähnt, verwenden Sie den Befehl watch auf jeden Fall, wenn er verfügbar ist. Einige Unix-Systeme haben es jedoch nicht standardmäßig installiert (zumindest nicht dort, wo ich arbeite).

Hier ist eine andere Lösung mit etwas anderer Syntax und Ausgabe (funktioniert in BASH und SH):

while [ 1 ] ; do
    <cmd>
    sleep <x>
    echo ">>>>>>>>>>>>>" `date` ">>>>>>>>>>>>>>"
done

Bearbeiten: Ich habe einige "." in der letzten Echo-Aussage ... Überbleibsel aus meinen Perl-Tagen;)

3
bedwyr

Was wäre, wenn wir beide hätten?

Hier ist die Idee: Mit nur "Intervall" wiederholt es sich für immer. Bei "Intervall" und "Zeiten" wird diese Anzahl wiederholt, getrennt durch "Intervall".

Die Verwendung :

$ loop [interval [times]] command

Der Algorithmus lautet also:

  • Listenpunkt
  • wenn $ 1 nur Ziffern enthält, ist dies das Intervall (Standard 2).
  • wenn $ 2 nur Ziffern enthält, ist dies die Häufigkeit (Standard unendlich).
  • while-Schleife mit diesen Parametern
    • schlaf "Intervall"
    • wenn mehrmals angegeben wurde, dekrementieren Sie eine Variable, bis sie erreicht ist

Deshalb :

loop() {
    local i=2 t=1 cond

    [ -z ${1//[0-9]/} ] && i=$1 && shift
    [ -z ${1//[0-9]/} ] && t=$1 && shift && cond=1
    while [ $t -gt 0 ]; do 
        sleep $i
        [ $cond ] && : $[--t]
        [email protected]
    done
}
3
Baronsed

Am Ende habe ich eine Variante der Antwort von Swalog erstellt. Mit seiner musste man X Sekunden auf die erste Iteration warten, ich renne meine auch im Vordergrund also ..

./foo.sh;while sleep 1; do (./foo.sh) ; done
2
Duane Lortie

Sie können die Leistung von python Interpreter von Shell erhalten.

python3 -c "import time, os
while True:
    os.system('your command')
    time.sleep(5)

ersetzen Sie fünf in einer beliebigen Zeit (Sek.).

Achtung: Die Rückgabe verwendet UMSCHALT + EINGABETASTE, um die Eingabe in Shell zurückzugeben. Und vergessen Sie nicht, 4 LEERZEICHEN Einzug in jede Zeile in der while-Schleife einzugeben.

1
pah8J

Einfache Möglichkeit, einen Auftrag von crontab in einem Intervall von weniger als einer Minute zu wiederholen (Beispiel 20 Sekunden):

crontab: * * * * * script.sh

script.sh:

#!/bin/bash
>>type your commands here.

sleep 20
>>retype your commands here.

sleep 20
>>retype your commands here.
1
Charles nakhel

Sie können ein Skript von init aus ausführen (Hinzufügen einer Zeile zu/etc/inittab). Dieses Skript muss Ihren Befehl ausführen, die Zeit warten, die Sie warten möchten, bis das Skript erneut ausgeführt wird, und es beenden. Init startet Ihr Skript nach dem Beenden erneut.

1
Roberto Paz

Schnell, schmutzig und wahrscheinlich gefährlich zu booten, aber wenn Sie abenteuerlustig sind und wissen, was Sie tun, geben Sie dies in repeat.sh Und chmod 755 Ein.

while true
do 
    eval $1 
    sleep $2 
done

Rufe es mit ./repeat.sh <command> <interval> Auf

Mein Spidey Sense sagt, dass dies wahrscheinlich eine böse Art ist, dies zu tun. Ist mein Spidey Sense richtig?

1
mallyone
#! /bin/sh

# Run all programs in a directory in parallel
# Usage: run-parallel directory delay
# Copyright 2013 by Marc Perkel
# docs at http://wiki.junkemailfilter.com/index.php/How_to_run_a_Linux_script_every_few_seconds_under_cron"
# Free to use with attribution

if [ $# -eq 0 ]
then
   echo
   echo "run-parallel by Marc Perkel"
   echo
   echo "This program is used to run all programs in a directory in parallel" 
   echo "or to rerun them every X seconds for one minute."
   echo "Think of this program as cron with seconds resolution."
   echo
   echo "Usage: run-parallel [directory] [delay]"
   echo
   echo "Examples:"
   echo "   run-parallel /etc/cron.20sec 20"
   echo "   run-parallel 20"
   echo "   # Runs all executable files in /etc/cron.20sec every 20 seconds or 3 times a minute."
   echo 
   echo "If delay parameter is missing it runs everything once and exits."
   echo "If only delay is passed then the directory /etc/cron.[delay]sec is assumed."
   echo
   echo 'if "cronsec" is passed then it runs all of these delays 2 3 4 5 6 10 12 15 20 30'
   echo "resulting in 30 20 15 12 10 6 5 4 3 2 executions per minute." 
   echo
   exit
fi

# If "cronsec" is passed as a parameter then run all the delays in parallel

if [ $1 = cronsec ]
then
   $0 2 &
   $0 3 &
   $0 4 &
   $0 5 &
   $0 6 &
   $0 10 &
   $0 12 &
   $0 15 &
   $0 20 &
   $0 30 &
   exit
fi

# Set the directory to first prameter and delay to second parameter

dir=$1
delay=$2

# If only parameter is 2,3,4,5,6,10,12,15,20,30 then automatically calculate 
# the standard directory name /etc/cron.[delay]sec

if [[ "$1" =~ ^(2|3|4|5|6|10|12|15|20|30)$ ]]
then
   dir="/etc/cron.$1sec"
   delay=$1
fi

# Exit if directory doesn't exist or has no files

if [ ! "$(ls -A $dir/)" ]
then
   exit
fi

# Sleep if both $delay and $counter are set

if [ ! -z $delay ] && [ ! -z $counter ]
then
   sleep $delay
fi

# Set counter to 0 if not set

if [ -z $counter ]
then
   counter=0
fi

# Run all the programs in the directory in parallel
# Use of timeout ensures that the processes are killed if they run too long

for program in $dir/* ; do
   if [ -x $program ] 
   then
      if [ "0$delay" -gt 1 ] 
      then
         timeout $delay $program &> /dev/null &
      else
         $program &> /dev/null &
      fi
   fi
done

# If delay not set then we're done

if [ -z $delay ]
then
   exit
fi

# Add delay to counter

counter=$(( $counter + $delay ))

# If minute is not up - call self recursively

if [ $counter -lt 60 ]
then
   . $0 $dir $delay &
fi

# Otherwise we're done
0
user56318

... Ich frage mich, wie viel komplizierte Lösungen bei der Lösung dieses Problems erstellt werden können.

Es kann so einfach sein ...

open /etc/crontab 

setzen Sie dort 1 nächste Zeile an das Ende der Datei wie:

*/NumberOfSeconds * * * * user /path/to/file.sh

Wenn Sie alle 1 Sekunde etwas ausführen möchten, geben Sie einfach Folgendes ein:

*/60 * * * * root /path/to/file.sh 

where that file.sh could be chmod 750 /path/to/file.sh

und innerhalb dieser Datei sollte.sh sein:

#!/bin/bash 
#What does it do
#What is it runned by

your code or commands

und das ist alles!

GENIESSEN!

0
MIrra

Mit zsh und einer sleep Implementierung, die Gleitkomma-Argumente akzeptiert:

typeset -F SECONDS=0 n=0
repeat 100 {cmd; sleep $(((n+=3) - SECONDS))}

Oder für forever:

for ((;;)) {cmd; sleep $(((n+=3) - SECONDS))}

Wenn Ihr sleep keine Floats unterstützt, können Sie es jederzeit als Wrapper um das eingebaute zsh von zselect neu definieren:

zmodload zsh/zselect
sleep() zselect -t $((($1 * 100) | 0))
0

Sie könnten diese rekursive Funktion verwenden:

#!/bin/bash
ininterval () {
    delay=$1
    shift
    $*
    sleep $delay
    ininterval $delay $*
}

oder fügen Sie ein:

ininterval $*

und rufen Sie das Skript auf.

0
user unknown

Um einen Befehl wiederholt in einem Konsolenfenster auszuführen, führe ich normalerweise Folgendes aus:

while true; do (run command here); done

Dies funktioniert auch für mehrere Befehle, um beispielsweise eine ständig aktualisierte Uhr in einem Konsolenfenster anzuzeigen:

while true; do clear; date; sleep 1; done

0
Thomas Bratt

Diese Lösung funktioniert unter MacOSX 10.7. Es funktioniert wunderbar.

bash -c 'while [ 0 ]; do \
      echo "I will not automate this punishment in absurdum."; done'

In meinem Fall

bash -c 'while [ 0 ]; do ls; done'

oder

bash -c 'while [ 0 ]; do mv "Desktop/* Documents/Cleanup"; done'

um meinen Desktop ständig aufzuräumen.

0
Dan Ruiz