it-swarm-tr.com

Unix komutunu her x saniyede bir sonsuza kadar tekrarla

İlk argümanı bir komutun tekrarlanma sayısı olan yerleşik bir Unix komutu repeat vardır; burada komut (herhangi bir argümanla birlikte) repeat için bağımsız değişkenlerle belirtilir.

Örneğin,

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

verilen dizeyi 100 kez yankılar ve sonra durur.

Benzer bir komut istiyorum - diyelim forever - ilk argüman tekrarlar arasında duraklama saniye saniye dışında benzer şekilde çalışır ve sonsuza kadar tekrarlar. Örneğin,

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

Yazmadan önce böyle bir şeyin olup olmadığını soracağımı düşündüm. Bunun 2 satırlı Perl veya Python komut dosyası gibi olduğunu biliyorum, ancak belki de bunu yapmanın daha standart bir yolu var. Değilse, en sevdiğiniz komut dosyası dilinde bir çözüm yayınlamaktan çekinmeyin.

Not: Belki de bunu yapmanın daha iyi bir yolu, hem tekrarlama sayısını (sonsuzluk anlamına gelen -1) hem de tekrarlar arasında uyumak için saniye sayısını almak üzere repeat'yi genelleştirmek olacaktır. Yukarıdaki örnekler daha sonra:

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

watch komutunu deneyin.

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

Böylece:

watch -n1  command

komutu saniyede bir (teknik olarak, her bir saniyede bir artı artı command için watch (en azından procps ve busybox uygulamalar) sonsuza dek command) iki çalışması arasında sadece bir saniye uyur.

Komutu sh -c Yerine exec öğesine geçirmek ister misiniz, -x Seçeneğini kullanın:

watch -n1 -x command

MacOS'ta, Mac Bağlantı Noktalarındanwatch alabilirsiniz:

port install watch

Veya Homebrew adresinden alabilirsiniz:

brew install watch
637
Gregor Brandt

Bash

while + sleep:

while true
do 
    echo "Hi"
    sleep 1
done

İşte stenografi tek astar ile aynı şey (Aşağıdaki yorumlardan):

while sleep 1; do echo "Hi"; done

Kullanır ; komutları ayırmak ve sleep 1while testi için her zaman true değerini döndürdüğü için. Döngü içine daha fazla komut koyabilirsiniz - bunları ;

255
pope

Bu, günlük rutininiz gibi bu tür görevleri sık sık çalıştırıyorsanız, diğer while+sleep Yanıtlarının daha kısa bir sürümüdür, bunu kullanmak sizi gereksiz tuşlara basmaktan kurtarır ve komut satırınız bunu daha uzun anlamaya başlarsa biri biraz daha kolay. Ama bu önce uyku ile başlar.

Makine yükü gibi tek satırlık bir çıktıya sahip olmanız gerekiyorsa bu genellikle yararlıdır:

while sleep 1; do uptime; done
73
Bekir Dogan

Şimdiye kadar gönderilen tüm cevapların sahip olduğu bir sorun, komutun yürütülme zamanının sürüklenebilmesidir. Örneğin, bir sleep 10 komutları arasında ve komutun çalışması 2 saniye sürer, o zaman her 12 saniyede bir çalışır; çalıştırmak için değişken bir süre gerekiyorsa, uzun vadede çalıştığı zaman öngörülemez olabilir.

Bu tam istediğiniz şey olabilir; öyleyse, diğer çözümlerden birini kullanın veya bunu kullanın ancak sleep çağrısını basitleştirin.

Bir dakikalık çözümleme için, her komutun ne kadar sürdüğüne bakılmaksızın cron işleri belirtilen zamanda çalışır. (Aslında bir önceki iş hala çalışıyor olsa bile yeni bir cron işi başlayacaktır.)

İşte bir sonraki aralığa kadar uyuyan basit bir Perl betiği, bu nedenle örneğin 10 saniyelik bir aralıkta komut, 12:34:00, 12:34:10, 12:34:20, vb. De çalışabilir. komutunun kendisi birkaç saniye sürer. Komut interval saniyeden fazla çalışırsa, bir sonraki aralık atlanır (cron'un aksine). Aralık, Epoch'a göre hesaplanır, bu nedenle 86400 saniye (1 gün) aralığı UTC gece yarısı çalışır.

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

Bence buradaki tüm cevaplar çok kıvrımlı ya da farklı bir soruyu cevaplıyor:

  • "Program bittikten sonraki başlatma arasında X saniye gecikmesi olması için bir programın art arda nasıl çalıştırılacağı".

Asıl soru şuydu:

  • "Her X saniyede bir program nasıl çalıştırılır"

Komutun bitmesi zaman aldığında bunlar çok farklı iki şeydir.

Örneğin foo.sh Komut dosyasını ele alalım (bunun tamamlanması birkaç saniye süren bir program gibi davran).

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

Bunu her saniye çalıştırmak istiyorsunuz ve çoğu watch -n1 ./foo.sh Veya while sleep 1; do ./foo.sh; done Önerecektir. Ancak, bu çıktı verir:

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

Bu her saniye tam olarak çalıştırılmıyor. -p Bayrağıyla bile man watch Sayfasının bunu çözebileceğini belirttiği gibi, sonuç aynı.

Biraz dokunulması istenen görevi gerçekleştirmenin kolay bir yolu, komutu arka planda çalıştırmaktır. Başka bir deyişle:

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

Ve hepsi bu kadar.

Her 500 ms'de bir sleep 0.5 İle çalıştırabilirsiniz.

33
swalog

bash içinde:

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

(echo herhangi bir komutla değiştirilebilir ...

Veya Perl içinde:

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

Nerede print "I will not automate this punishment in absurdum.\n", ters çentiklerle (") çevrili" herhangi bir "komutla değiştirilebilir.

Ve duraklama için for döngüsünün içine sleep ifadesi ekleyin:

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

ve

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

Son Linux çekirdeği tabanlı cevap altında Son bash> = 4.2.

Uygulama süresini sınırlamak için çatal yok ! Yalnızca yerleşik olarak kullanılır.

Bunun için read yerine sleep yerleşik işlevini kullanıyorum. Ne yazık ki bu notty oturumları ile çalışmaz.

Hızlı bash işlevi "repeat" istendiği gibi:

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
}

Alıntılanan dizelerle küçük test:

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

Gönderilen komutun ayrıntı düzeyine ve süresine bağlı olarak ...

Son Linux çekirdekleri altında, bir procfile /proc/timer_list nanosaniye cinsinden zaman bilgisi içerir.

Bir komutu tam olarak saniyede bir çalıştırmak istiyorsanız, komutunuzun bir saniyeden daha kısa sürede bitmesi gerekir! Ve oradan sleep sadece dinlenme geçerli saniye.

Gecikme daha önemliyse ve komutunuz önemli bir zaman gerektirmiyorsa şunları yapabilirsiniz:

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

Ancak hedefiniz daha küçük ayrıntı düzeyi elde etmekse, şunları yapmanız gerekir:

Bir saniyenin başlangıcına kadar beklemek için nanosaniye bilgilerini kullanın ...

Bunun için küçük bir bash işlevi yazdım:

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

Onları tedarik ettikten sonra şunları yapabilirsiniz:

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

çalıştırmak ${command[@]} ile karşılaştırmak yerine doğrudan komut satırında

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

bu tamamen aynı sonucu vermelidir.

İşe alınan bash işlevi "repeat" istendiği gibi:

Bu kaynak olabilir:

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
}

Sonra deneyin:

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 ve akrabalarından bazılarında kullanışlı (( ... )) notasyonu burada aritmetik ifadeler değerlendirilebilir.

Dolayısıyla, her bir tekrar arasındaki tekrar sayımının ve gecikmenin yapılandırılabilir olması gereken üçüncü zorluğunuza bir cevap olarak, bunu yapmanın bir yolu var:

repeat=10
delay=1

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

Bu cevap ayrıca Keith'in cevabı kapsamındaki zamanlama sapmasından da muzdariptir.

4
Thor

Niyetiniz ekranınızda bir mesaj görüntülemek değilse ve işi dakikalar içinde tekrarlamayı göze alabiliyorsanız crontab , belki de en iyi aracınız olacaktır. Örneğin, komutunuzu her dakika yürütmek isterseniz, crontab dosyanıza böyle bir şey yazarsınız:

* * * * * my_precious_command

Daha fazla örnek için lütfen eğiticiye göz atın. Ayrıca, Crontab Code Generator kullanarak zamanlamaları kolayca ayarlayabilirsiniz.

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

Bunu denemek ister misin (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

Gbrandt tarafından belirtildiği gibi, watch komutu varsa, kesinlikle kullanın. Bununla birlikte, bazı Unix sistemleri varsayılan olarak yüklü değildir (en azından çalıştığım yerde yok).

İşte biraz farklı sözdizimi ve çıktısı olan başka bir çözüm (BASH ve SH'de çalışır):

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

Düzenleme: Bazı "." son yankı ifadesinde ... Perl günlerimden kalma;)

3
bedwyr

Ya ikimiz de olsaydı?

İşte fikir: sadece "aralık" ile sonsuza kadar tekrar eder. "Aralık" ve "zamanlar" ile, bu zaman aralığını "aralık" ile ayırarak tekrar eder.

Kullanım :

$ loop [interval [times]] command

Yani, algoritma şöyle olacaktır:

  • Liste öğesi
  • $ 1 yalnızca rakam içeriyorsa, aralıktır (varsayılan 2)
  • $ 2 yalnızca rakam içeriyorsa, sayıdır (varsayılan sonsuz)
  • while bu parametrelerle döngü
    • uyku "aralığı"
    • eğer birkaç kez verilmişse, ulaşılana kadar bir varyasyonu azaltın

Bu nedenle:

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

Swalog'un cevabında bir varyant yaratarak yaralandım. Onunla ilk iterasyon için X saniye beklemek zorundaydın, ben de ön planda koşuyorum yani ..

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

Gücü python tercümandan Shell'den alabilirsiniz.

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

beşi istediğiniz zaman (sn) değiştirin.

Dikkat: dönüş, Shell'deki girişi döndürmek için ÜSTKRKT + ENTER tuşlarını kullanın. While döngüsünde her satıra 4 BOŞLUK girinti eklemeyi unutmayın.

1
pah8J

Bir işi crontab'dan bir dakikadan daha kısa aralıklarla tekrarlamanın kolay yolu (20 saniye örnek):

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

İnit'ten bir komut dosyası çalıştırabilirsiniz (/ etc/inittab dosyasına bir satır ekleyerek). Bu komut dosyasının komutunuzu çalıştırması, komut dosyasını yeniden çalıştıracak kadar beklemek istediğiniz süre uyuması ve komuttan çıkması gerekir. Init, çıkıştan sonra komut dosyanızı yeniden başlatır.

1
Roberto Paz

Hızlı, kirli ve muhtemelen önyükleme yapmak tehlikeli, ancak maceracıysanız ve ne yaptığınızı biliyorsanız, bunu repeat.sh Ve chmod 755 İçine koyun,

while true
do 
    eval $1 
    sleep $2 
done

./repeat.sh <command> <interval> İle çağırın

Örümcek duygum, bunun muhtemelen bunu yapmanın kötü bir yolu olduğunu söylüyor, örümcek duyum doğru mu?

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

... bu sorunu çözerken ne kadar karmaşık çözümlerin yaratılabileceğini merak ediyorum.

Çok kolay olabilir ...

open /etc/crontab 

dosyanın sonuna aşağıdaki gibi bir sonraki satır koyun:

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

Her 1 saniyede bir şey çalıştırmak istiyorsanız, oraya koyun:

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

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

ve bu dosyanın.sh içinde:

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

your code or commands

ve hepsi bu!

ZEVK ALMAK!

0
MIrra

zsh ve kayan nokta argümanlarını kabul eden bir sleep uygulaması ile:

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

Veya forever için:

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

sleep öğeniz kayan reklamları desteklemiyorsa, zsh 's zselect yerleşik etrafında her zaman bir paket olarak yeniden tanımlayabilirsiniz:

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

Bu özyinelemeli işlevi kaynaklayabilirsiniz:

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

veya ekleyin:

ininterval $*

ve komut dosyasını çağırınız.

0
user unknown

Bir konsol penceresinde tekrar tekrar bir komut çalıştırmak için genellikle böyle bir şey çalıştırın:

while true; do (run command here); done

Bu, örneğin bir konsol penceresinde sürekli güncellenen bir saati görüntülemek için birden fazla komut için de çalışır:

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

0
Thomas Bratt

Bu çözüm MacOSX 10.7'de çalışır. Harika çalışıyor.

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

Benim durumumda

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

veya

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

masaüstümü sürekli temizlemek için.

0
Dan Ruiz