Linux terminalinde gerçek zamanlı bir geri sayım sayacını nasıl görüntüleyebilirim? Mevcut bir uygulama veya daha da iyisi, bunu yapmak için bir astar var mı?

Neden ihtiyacın olduğundan emin değilim beep, tek istediğin bir kronometre ise, bunu yapabilirsin:

while true; do echo -ne "`date`\r"; done

Bu size gerçek zamanlı olarak geçen saniyeleri gösterir ve bunu Ctrl+ ile durdurabilirsiniz C. Daha fazla hassasiyete ihtiyacınız varsa, nanosaniye vermek için bunu kullanabilirsiniz:

while true; do echo -ne "`date +%H:%M:%S:%N`\r"; done

Son olarak, gerçekten, gerçekten "kronometre biçimini" istiyorsanız, her şeyin 0 ile başladığı ve büyümeye başladığı yerde, şöyle bir şey yapabilirsiniz:

date1=`date +%s`; while true; do 
   echo -ne "$(date -u --date @$((`date +%s` - $date1)) +%H:%M:%S)\r";
done

Bir geri sayım sayacı için (asıl sorunuzun sorduğu şey bu değildi) bunu yapabilirsiniz (buna göre saniyeler değiştirin):

seconds=20; date1=$((`date +%s` + $seconds)); 
while [ "$date1" -ge `date +%s` ]; do 
  echo -ne "$(date -u --date @$(($date1 - `date +%s` )) +%H:%M:%S)\r"; 
done

Bunları bash (veya hangi kabuğu tercih ederseniz) işlevlerini kullanarak basit komutlarda birleştirebilirsiniz. Kısaca, bu satırları kendinize ekleyin ~/.bashrc( sleep 0.1sistemi her çalıştırma arasında saniyenin 1 / 10'unu bekletir, böylece işlemcinizi spam yapmazsınız):

function countdown(){
   date1=$((`date +%s` + $1)); 
   while [ "$date1" -ge `date +%s` ]; do 
     echo -ne "$(date -u --date @$(($date1 - `date +%s`)) +%H:%M:%S)\r";
     sleep 0.1
   done
}
function stopwatch(){
  date1=`date +%s`; 
   while true; do 
    echo -ne "$(date -u --date @$((`date +%s` - $date1)) +%H:%M:%S)\r"; 
    sleep 0.1
   done
}

Daha sonra çalıştırarak bir dakikalık bir geri sayım sayacını başlatabilirsiniz:

countdown 60

İki saatte bir geri sayım yapabilirsiniz:

countdown $((2*60*60))

veya şunları kullanarak bütün bir gün:

countdown $((24*60*60))

Ve kronometreyi çalıştırarak başlayın:

stopwatch

Günlerle, saatlerle, dakikalarla ve saniyelerle başa çıkmanız gerekirse, şöyle bir şey yapabilirsiniz:

countdown(){
    date1=$((`date +%s` + $1));
    while [ "$date1" -ge `date +%s` ]; do 
    ## Is this more than 24h away?
    days=$(($(($(( $date1 - $(date +%s))) * 1 ))/86400))
    echo -ne "$days day(s) and $(date -u --date @$(($date1 - `date +%s`)) +%H:%M:%S)\r"; 
    sleep 0.1
    done
}
stopwatch(){
    date1=`date +%s`; 
    while true; do 
    days=$(( $(($(date +%s) - date1)) / 86400 ))
    echo -ne "$days day(s) and $(date -u --date @$((`date +%s` - $date1)) +%H:%M:%S)\r";
    sleep 0.1
    done
}

Not stopwatchGerçekten bunun için 24 saat bekleyin istemiyordu çünkü fonksiyon gündür test edilmemiştir. İşe yaramalı, ama işe yaramadığını lütfen bana bildirin.

En sevdiğim yol:

Başlat:

time cat

Dur:

ctrl+c

@Wjandrea aşağıda yorum yaptığı gibi, başka bir sürüm çalıştırmaktır:

time read

ve Enterdurdurmak için tuşuna basın .

Aynı şeyi arıyordum ve Python'da daha ayrıntılı bir şeyler yazmaya başladım:

Bu size 10 saniyelik basit bir geri sayım verecektir:

sudo pip install termdown
termdown 10

Kaynak: https://github.com/trehn/termdown

Bunu kullandım:

countdown()
(
  IFS=:
  set -- $*
  secs=$(( ${1#0} * 3600 + ${2#0} * 60 + ${3#0} ))
  while [ $secs -gt 0 ]
  do
    sleep 1 &
    printf "\r%02d:%02d:%02d" $((secs/3600)) $(( (secs/60)%60)) $((secs%60))
    secs=$(( $secs - 1 ))
    wait
  done
  echo
)

Örnek:

 countdown "00:07:55"

İşte bir kaynak .

sh-3.2# man leave

15 dakika boyunca bir zamanlayıcı ayarlamak

sh-3.2# leave +0015
Alarm set for Thu Nov  3 14:19:31 CDT 2016. (pid 94317)
sh-3.2#

düzenleme: Açık bir sürü bağlantı vardı ve bunun osx'a özgü olduğunu düşündüm, bunun için üzgünüm. Cevabımı yukarı bırakmak, böylece diğerleri BSD'ler üzerindeki izinlerin farkında olsun.

Bu, yüzlerce saniyelik bir kronometre için:

#!/usr/bin/awk -f
function z() {
  getline < "/proc/uptime"
  close("/proc/uptime")
  return $0
}
BEGIN {
  x = z()
  while (1) {
    y = z()
    printf "%02d:%05.2f\r", (y - x) / 60, (y - x) % 60
  }
}

Örnek

Terdon'un cevabını çok iyi bir şekilde birleştirdim, aynı zamanda başlangıçtan itibaren zamanı ve bitiş zamanını da gösteren fonksiyona. Üç çeşit de var, bu yüzden çağırması daha kolay (bash matematiği yapmak zorunda değilsiniz) ve aynı zamanda soyutlanmış. Kullanım örneği :

{ ~ }  » time_minutes 15
Counting to 15 minutes
Start at 11:55:34     Will finish at 12:10:34
     Since start: 00:00:08     Till end:  00:14:51

Ve çalışma zamanlayıcısı gibi bir şey:

{ ~ }  » time_hours 8
Counting to 8 hours
Start at 11:59:35   Will finish at 19:59:35
     Since start: 00:32:41     Till end:  07:27:19

Ve çok özel bir zamana ihtiyacınız varsa:

{ ~ }  » time_flexible 3:23:00
Counting to 3:23:00 hours
Start at 12:35:11   Will finish at 15:58:11
     Since start: 00:00:14     Till end:  03:22:46

İşte .bashrc içine koymak için kod

function time_func()
{
   date2=$((`date +%s` + $1));
   date1=`date +%s`;
   date_finish="$(date --date @$(($date2)) +%T )"

   echo "Start at `date +%T`   Will finish at $date_finish"

    while [ "$date2" -ne `date +%s` ]; do
     echo -ne "     Since start: $(date -u --date @$((`date +%s` - $date1)) +%H:%M:%S)     Till end:  $(date -u --date @$(($date2 - `date +%s`)) +%H:%M:%S)\r";
     sleep 1
    done

    printf "\nTimer finished!\n"
    play_sound ~/finished.wav
}

function time_seconds()
{
  echo "Counting to $1 seconds"
  time_func $1
}

function time_minutes()
{
  echo "Counting to $1 minutes"
  time_func $1*60
}

function time_hours()
{
  echo "Counting to $1 hours"
  time_func $1*60*60
}

function time_flexible()  # accepts flexible input hh:mm:ss
{
    echo "Counting to $1"
    secs=$(time2seconds $1)
    time_func $secs
}

function play_sound()  # adjust to your system
{
    cat $1 > /dev/dsp
}

function time2seconds() # changes hh:mm:ss to seconds, found on some other stack answer
{ 
    a=( ${1//:/ }) 
    echo $((${a[0]}*3600+${a[1]}*60+${a[2]})) 
}

Bunu linux terminalinde ( Linux komut satırından mp3 veya wav dosyası oynatın ) veya cygwin'de ( babun / win7'de benim için çalışır ) ses çalmanın bir yolunu birleştirin ve alarmlı basit bir esnek zamanlayıcıya sahipsiniz !cat /path/foo.wav > /dev/dsp

Başka bir yaklaşım

countdown=60 now=$(date +%s) watch -tpn1 echo '$((now-$(date +%s)+countdown))'

Mac için:

countdown=60 now=$(date +%s) watch -tn1 echo '$((now-$(date +%s)+countdown))'
#no p option on mac for watch

Eğer biri sıfıra ulaştığında bir sinyal isterse, örneğin, sıfır olmayan bir çıkış durumu döndüren ve sıfır watch -bveya başka bir şeyle birleştiren bir komutla oluşturabilir , ancak daha ayrıntılı bir komut dosyası oluşturmak istiyorsanız, bu muhtemelen gitmenin yolu değil; "hızlı ve kirli bir astar" tipinde bir çözümden daha fazlasıdır.

watchProgramı genel olarak seviyorum . Bunu, ilk defa while sleep 5; dofarklı efektlere sayısız döngü yazdıktan sonra gördüm . watchgözle görülür şekilde daha güzeldi.

Kendi kabuk betiğimi yazdım: github gist

#!/bin/sh
# script to create timer in terminal
# Jason Atwood
# 2013/6/22

# start up
echo "starting timer script ..."
sleep 1 # seconds

# get input from user
read -p "Timer for how many minutes?" -e DURATION
DURATION=$(( $DURATION*60 )) # convert minutes to seconds

# get start time
START=$(date +%s)

# infinite loop
while [ -1 ]; do
clear # clear window

# do math
NOW=$(date +%s) # get time now in seconds
DIF=$(( $NOW-$START ))  # compute diff in seconds
ELAPSE=$(( $DURATION-$DIF ))    # compute elapsed time in seconds
MINS=$(( $ELAPSE/60 ))  # convert to minutes... (dumps remainder from division)
SECS=$(( $ELAPSE - ($MINS*60) )) # ... and seconds

# conditional
if [ $MINS == 0 ] && [ $SECS == 0 ] # if mins = 0 and secs = 0 (i.e. if time expired)
then # blink screen
for i in `seq 1 180`; # for i = 1:180 (i.e. 180 seconds)
do
clear # flash on
setterm -term linux -back red -fore white # use setterm to change background color
echo "00:00 " # extra tabs for visibiltiy

sleep 0.5

clear # flash off
setterm -term linux -default # clear setterm changes from above
echo "00:00" # (i.e. go back to white text on black background)
sleep 0.5
done # end for loop
break   # end script

else # else, time is not expired
echo "$MINS:$SECS"  # display time
sleep 1 # sleep 1 second
fi  # end if
done    # end while loop 

sleepenhAracı kimsenin yazılarında kullanmamasına şaşırdım . Bunun yerine önerilen çözümler ya sleep 1sonraki zamanlayıcı çıkışları arasında ya da mümkün olduğu kadar hızlı çıkış yapan meşgul bir döngü kullanır. Birincisi yetersiz; çünkü baskı için harcanan az zamandan dolayı çıktı gerçekte saniyede bir kez gerçekleşmeyecek, ancak en düşük değer olandan biraz daha az olacaktır. Yeterli zaman geçtikten sonra sayaç bir saniye atlayacaktır. İkincisi yetersizdir, çünkü CPU'yu hiçbir sebep olmadan meşgul eder.

İçimdeki araç $PATHşuna benziyor:

#!/bin/sh
if [ $# -eq 0 ]; then
    TIMESTAMP=$(sleepenh 0)
    before=$(date +%s)
    while true; do
        diff=$(($(date +%s) - before))
        printf "%02d:%02d:%02d\r" $((diff/3600)) $(((diff%3600)/60)) $((diff%60))
        TIMESTAMP=$(sleepenh $TIMESTAMP 1.0);
    done
    exit 1 # this should never be reached
fi
echo "counting up to $@"
"$0" &
counterpid=$!
trap "exit" INT TERM
trap "kill 0" EXIT
sleep "$@"
kill $counterpid

Komut dosyası, kronometre olarak (kesilene kadar sayma) veya belirtilen süre boyunca çalışan bir zamanlayıcı olarak kullanılabilir. Yana sleepkomut kullanılır, bu yazı sizin aynı hassasiyetle saymak süresini belirlemenizi sağlar sleepverir. Debian ve türevlerinde, alt saniye uykular ve zamanı belirtmek için insan tarafından okunabilir güzel bir yol var. Mesela şöyle diyebilirsiniz:

$ time countdown 2m 4.6s
countdown 2m 4.6s  0.00s user 0.00s system 0% cpu 2:04.60 total

Ve gördüğünüz gibi, komut tam olarak 2 dakika ve 4.6 saniye boyunca senaryoda fazla sihir olmadan çalıştı.

EDIT :

Sleepenh aracı, Debian'daki ve aynı türdeki Ubuntu gibi türevlerinin bulunduğu paketten geliyor. Sahip olmayan dağıtımlar için, https://github.com/nsc-deb/sleepenh adresinden geliyor.

Sleepenh'in avantajı, döngü sırasında uykudan başka şeylerin işlenmesinden zaman içinde biriken küçük gecikmeyi hesaba katabilmesidir. Biri sadece sleep 110 kez bir döngüde olsa bile , genel uygulama sleep, döngüyü yürütme ve yineleme işleminden kaynaklanan küçük ek yük nedeniyle 10 saniyeden biraz daha uzun sürecektir . Bu hata yavaşça birikir ve zaman içinde kronometre zamanlayıcımızı daha da belirsiz hale getirir. Bu sorunu çözmek için, her bir döngü yinelemesinin uyku için kesin zamanı hesaplaması gerekir (genellikle bir saniyeden biraz daha kısadır) (bir saniye aralıklı zamanlayıcılar için). Sleepenh aracı bunu sizin için yapar.

Kısa cevap:

for i in `seq 60 -1 1` ; do echo -ne "\r$i " ; sleep 1 ; done

Açıklama:

Çok fazla cevap olduğunu biliyorum, ancak sadece OP'nin sorusuna çok yakın bir şey göndermek istiyorum, şahsen " terminalde oneliner geri sayımı " olarak kabul ediyorum . Hedeflerim:

1. Bir astar.
2. Geri sayım.
3. Konsolu hatırlaması ve yazması kolaydır (işlev yok ve ağır mantık, yalnızca bash).
4. Yüklemek için ek bir yazılım gerektirmez (orada root olmasam bile, ssh ile gittiğim herhangi bir sunucuda kullanılabilir).

Nasıl çalışır:

1. seq 60 ile 1 arasında sayıları yazdırır.
2. echo -ne "\r$i "dizeyi karakterin başına döndürür ve geçerli $ideğeri yazdırır . Geçerli değerden karakterlere göre daha uzun olsaydı, önceki değerin üzerine yazmak için gerekli olan boşluk $i(10 -> 9).

Gelecekte referans olarak, geri sayım / geri sayım sayacı için çok basit komut satırı seçenekleriyle µTimer adlı bir komut satırı aracı var .

OSX'te bir komut satırı kronometre arayan biri olduğunuzu farzedin. Gnu araçlarını yüklemek istemediğinizi ve sadece unix ile çalışmak istediğinizi söyleyindate

Bu durumda @ terdon'ın dediği gibi yapın ama bu değişiklik:

function stopwatch(){
    date1=`date +%s`; 
    while true; do 
        echo -ne "$(date -jf "%s" $((`date +%s` - $date1)) +%H:%M:%S)\r"; 
        sleep 0.1
    done
}

UTC saatinde sadece watch + tarihini kullanın. Ayrıca büyük görüntü için bir paket de yükleyebilirsiniz ...

export now="`date +%s -u`";
watch -n 0,1 'date +%T -u -d @$((`date +%s` - $now ))'

#Big plain characters
watch -n 0,1 'date +%T -u -d @$((`date +%s` - $now )) | toilet -f mono12'

#Big empty charaters
watch -n 0,1 'date +%T -u -d @$((`date +%s` - $now )) | figlet -c -f big'

Dene!

Ayrıca bakınız http://www.cyberciti.biz/faq/create-large-colorful-text-banner-on-screen/

sw sonsuza kadar sürecek basit bir kronometredir.

Yüklemek

wget -q -O - http://git.io/sinister | sh -s -- -u https://raw.githubusercontent.com/coryfklein/sw/master/sw

kullanım

sw
 - start a stopwatch from 0, save start time in ~/.sw
sw [-r|--resume]
 - start a stopwatch from the last saved start time (or current time if no last saved start time exists)
 - "-r" stands for --resume

Bir python örneği:

#!/usr/bin/python

def stopwatch ( atom = .01 ):
    import time, sys, math

    start = time.time()
    last = start
    sleep = atom/2
    fmt = "\r%%.%sfs" % (int(abs(round(math.log(atom,10))))  if atom<1 else "")
    while True:
        curr = time.time()
        subatom = (curr-last)
        if subatom>atom:
            # sys.stdout.write( "\r%.2fs" % (curr-start))
            sys.stdout.write( fmt % (curr-start))
            sys.stdout.flush()
            last = curr
        else:
            time.sleep(atom-subatom)

stopwatch()

TermTime'a göz atın , güzel bir terminal tabanlı saat ve kronometre:

pip install termtime

Bu kabul edilen cevaba benzer, ancak terdon countdown()bana sözdizimi hataları verdi. Bu benim için harika çalışıyor ama:

function timer() { case "$1" in -s) shift;; *) set $(($1 * 60));; esac; local S=" "; for i in $(seq "$1" -1 1); do echo -ne "$S\r $i\r"; sleep 1; done; echo -e "$S\rTime's up!"; }

İçine koyabilir .bashrcve sonra ile yürütebilirsiniz: timer t(t dakika cinsinden zamandır).

Bir atölye için büyük bir geri sayım sayacı görüntülemek için bir terim uygulaması ararken, bugün bu soruyu daha önce buldum. Önerilerimin hiçbiri tam olarak ihtiyacım olan şey değildi, bu yüzden hızlı bir şekilde bir araya getirdim Go: https://github.com/bnaucler/cdown

Soru zaten yeterince cevaplandırıldığından, bunun iyilik uğruna olduğunu düşünün.

1500 $ && xterm uyku -df sarı -gg 240x80

Sarı metinli büyük terminal atladığında, ayağa kalkma ve uzama zamanı!

Notlar: - 1500 saniye = 25 dakika pomodoro - 240x80 = 240 karakter satırlı terminal boyutu ve 80 satır. Belirgin bir şekilde benim için bir ekran doldurur.

Kredi: http://www.linuxquestions.org/questions/linux-newbie-8/countdown-timer-for-linux-949463/

Kronometrenin GUI sürümü

date1=`date +%s`
date1_f=`date +%H:%M:%S____%d/%m`
(
  while true; do 
    date2=$(date -u --date @$((`date +%s` - $date1)) +%H:%M:%S)
    echo "# started at $date1_f \n$date2"
  done
) |
zenity --progress \
  --title="Stop Watch" \
  --text="Stop Watch..." \
  --percentage=0

Herhangi bir nedenden ötürü derlenebilir bir program istiyorsanız, aşağıdakiler işe yarayacaktır:

#include <iostream>
#include <string>
#include <chrono>

int timer(seconds count) {
  auto t1 = high_resolution_clock::now();
  auto t2 = t1+count;
  while ( t2 > high_resolution_clock::now()) {
    std::cout << "Seconds Left:" <<
    std::endl <<
      duration_cast<duration<double>>(count-(high_resolution_clock::now()-t1)).count() << 
    std::endl << "\033[2A\033[K";
    std::this_thread::sleep_for(milliseconds(100));
  }
  std::cout << "Finished" << std::endl;
  return 0;
}

Bir bash ortamı yoksa veya derlenmiş bir program kullanmayı tercih ederseniz, bu diğer programlarda da kullanılabilir ve kolayca taşınabilir.

github