ฉันจะแสดงตัวจับเวลาถอยหลังแบบเรียลไทม์บนเทอร์มินัล Linux ได้อย่างไร มีแอพพลิเคชั่นที่มีอยู่หรือดียิ่งขึ้นเพียงซับเดียวในการทำสิ่งนี้หรือไม่?

ฉันไม่แน่ใจว่าทำไมคุณต้องการbeepถ้าคุณต้องการเพียงแค่นาฬิกาจับเวลาคุณสามารถทำสิ่งนี้:

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

ที่จะแสดงวินาทีผ่านในเรียลไทม์และคุณสามารถหยุดมันด้วย+Ctrl Cหากคุณต้องการความแม่นยำมากขึ้นคุณสามารถใช้สิ่งนี้เพื่อมอบนาโนวินาทีให้กับคุณ:

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

ท้ายที่สุดถ้าคุณต้องการ "รูปแบบนาฬิกาจับเวลา" จริงๆซึ่งทุกอย่างเริ่มต้นที่ 0 และเริ่มเติบโตคุณสามารถทำสิ่งนี้:

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

สำหรับตัวจับเวลานับถอยหลัง (ซึ่งไม่ใช่คำถามเดิมของคุณ) คุณสามารถทำได้ (เปลี่ยนวินาทีตาม):

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

คุณสามารถรวมคำเหล่านี้เป็นคำสั่งง่ายๆโดยใช้ฟังก์ชัน bash (หรือเชลล์ใดก็ได้ที่คุณต้องการ) ในทุบตีเพิ่มบรรทัดเหล่านี้ของคุณ~/.bashrc( sleep 0.1จะทำให้ระบบรอ 1 / 10th ของวินาทีระหว่างแต่ละวิ่งเพื่อให้คุณไม่สแปม CPU ของคุณ):

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
}

จากนั้นคุณสามารถเริ่มจับเวลาถอยหลังหนึ่งนาทีโดยเรียกใช้:

countdown 60

คุณสามารถนับถอยหลังสองชั่วโมงด้วย:

countdown $((2*60*60))

หรือทั้งวันโดยใช้:

countdown $((24*60*60))

และเริ่มจับเวลาโดยเรียกใช้:

stopwatch

หากคุณต้องการจัดการกับวันรวมถึงชั่วโมงนาทีและวินาทีคุณสามารถทำสิ่งนี้:

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
}

โปรดทราบว่าstopwatchฟังก์ชั่นไม่ได้รับการทดสอบเป็นเวลาหลายวันเพราะฉันไม่ต้องการรอ 24 ชั่วโมง ควรใช้งานได้ แต่โปรดแจ้งให้เราทราบหากไม่ได้ผล

วิธีที่ฉันชอบคือ:

ราคาเริ่มต้น:

time cat

หยุด:

ctrl+c

ตามที่ @wjandrea แสดงความคิดเห็นด้านล่างเวอร์ชันอื่นจะทำงาน:

time read

และกดEnterเพื่อหยุด

ฉันกำลังมองหาสิ่งเดียวกันและจบลงด้วยการเขียนสิ่งที่ซับซ้อนยิ่งขึ้นใน Python:

สิ่งนี้จะทำให้คุณได้รับการนับถอยหลังอย่างง่าย ๆ 10 วินาที:

sudo pip install termdown
termdown 10

ที่มา: https://github.com/trehn/termdown

ฉันใช้อันนี้:

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
)

ตัวอย่าง:

 countdown "00:07:55"

ที่นี่เป็นแหล่งที่มา

sh-3.2# man leave

ตั้งเวลา 15 นาที

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

แก้ไข: ฉันเปิดลิงค์เป็นจำนวนมากและฉันคิดว่านี่เป็นสิ่งที่เฉพาะเจาะจงสำหรับ osx ขอโทษด้วย ออกจากคำตอบของฉันขึ้นเพื่อให้คนอื่นตระหนักถึงการลา BSDs

นี่สำหรับนาฬิกาจับเวลาที่มีสองร้อยวินาที:

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

ตัวอย่าง

ฉันได้รวมคำตอบที่ดีมากของ terdon เข้ากับฟังก์ชั่นซึ่งในเวลาเดียวกันแสดงเวลาตั้งแต่เริ่มต้นและเวลาจนถึงสิ้น นอกจากนี้ยังมีตัวแปรอีกสามแบบเพื่อให้ง่ายต่อการโทร (คุณไม่ต้องทำคณิตศาสตร์ทุบตี) และมันก็เป็นนามธรรม ตัวอย่างการใช้งาน :

{ ~ }  » 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

และสิ่งที่ชอบจับเวลาทำงาน:

{ ~ }  » 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

และถ้าคุณต้องการเวลาที่เจาะจงมาก:

{ ~ }  » 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

นี่คือรหัสที่จะใส่ลงใน. bashrc ของคุณ

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]})) 
}

รวมสิ่งนี้กับวิธีการเล่นเสียงใน linux terminal ( เล่นไฟล์ mp3 หรือ wav ผ่านทางบรรทัดคำสั่ง Linux ) หรือ cygwin ( cat /path/foo.wav > /dev/dsp เหมาะสำหรับฉันใน babun / win7) และคุณมีตัวจับเวลาที่ยืดหยุ่นได้ง่ายพร้อมสัญญาณเตือน !

อีกแนวทางหนึ่ง

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

สำหรับ Mac:

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

หากใครต้องการสัญญาณเมื่อมันมาถึงศูนย์หนึ่งสามารถสร้างมันด้วยคำสั่งที่ส่งกลับสถานะทางออกที่ไม่ใช่ศูนย์ที่ศูนย์และรวมกับwatch -bหรือบางสิ่งบางอย่าง แต่ถ้าใครต้องการที่จะสร้างสคริปต์ที่ซับซ้อนมากขึ้นนี้อาจเป็น ไม่ใช่ทางที่จะไป มันเป็นโซลูชันประเภท "แบบรวดเร็วและสกปรก" ที่มากกว่า

ฉันชอบwatchโปรแกรมทั่วไป ฉันเห็นเป็นครั้งแรกหลังจากเขียนwhile sleep 5; doลูปนับไม่ถ้วนไปยังเอฟเฟกต์ต่าง watchดีกว่า

ฉันลงเอยด้วยการเขียนเชลล์สคริปต์ของตัวเอง: 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 

ฉันประหลาดใจที่ไม่มีใครใช้sleepenhเครื่องมือในสคริปต์ของพวกเขา แต่โซลูชันที่นำเสนออาจใช้sleep 1ระหว่างเอาต์พุตตัวจับเวลาที่ตามมาหรือลูปที่ไม่ว่างซึ่งจะส่งเอาต์พุตโดยเร็วที่สุด อดีตไม่เพียงพอเนื่องจากมีเวลาน้อยที่ใช้ในการพิมพ์ผลลัพธ์จะไม่เกิดขึ้นจริงหนึ่งครั้งต่อวินาที แต่น้อยกว่าสิ่งที่ไม่ดีพอ หลังจากผ่านไปนานพอเคาน์เตอร์จะข้ามไปหนึ่งวินาที หลังไม่เพียงพอเพราะมันทำให้ CPU ไม่ว่างโดยไม่มีเหตุผลที่ดี

เครื่องมือที่ฉันมีใน$PATHหน้าตาแบบนี้:

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

สคริปต์สามารถใช้เป็นนาฬิกาจับเวลา (นับจนถึงการขัดจังหวะ) หรือเป็นตัวจับเวลาที่ทำงานตามระยะเวลาที่กำหนด เนื่องจากsleepมีการใช้คำสั่งสคริปต์นี้อนุญาตให้ระบุระยะเวลาที่จะนับในความแม่นยำเดียวกันกับที่คุณsleepอนุญาต บนเดเบียนและอนุพันธ์สิ่งนี้รวมถึงการพักวินาทีในวินาทีและเป็นวิธีที่มนุษย์สามารถอ่านได้ดีในการระบุเวลา ตัวอย่างเช่นคุณสามารถพูดได้:

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

และอย่างที่คุณเห็นคำสั่งวิ่งได้อย่างแม่นยำเป็นเวลา 2 นาทีและ 4.6 วินาทีโดยไม่ต้องใช้เวทมนตร์มากนักในสคริปต์

แก้ไข :

เครื่องมือ sleepenh มาจากแพ็คเกจชื่อเดียวกันใน Debian และอนุพันธ์ของมันเช่น Ubuntu สำหรับการแจกแจงที่ไม่มีมันมาจาก https://github.com/nsc-deb/sleepenh

ข้อดีของ sleepenh คือสามารถพิจารณาการหน่วงเวลาเล็กน้อยที่สะสมตลอดเวลาจากการประมวลผลของสิ่งอื่นนอกเหนือจากการนอนหลับในระหว่างการวนรอบ แม้ว่าจะมีเพียงหนึ่งsleep 1ในลูป 10 ครั้งการดำเนินการโดยรวมจะใช้เวลามากกว่า 10 วินาทีเนื่องจากโอเวอร์เฮดขนาดเล็กที่มาจากการดำเนินการsleepและวนซ้ำลูป ข้อผิดพลาดนี้จะสะสมอย่างช้าๆและเมื่อเวลาผ่านไปจะทำให้ตัวจับเวลานาฬิกาจับเวลาของเราไม่แน่นอนมากขึ้น ในการแก้ไขปัญหานี้เราต้องวนซ้ำแต่ละรอบเพื่อคำนวณเวลาที่แม่นยำในการนอนซึ่งปกติจะน้อยกว่าหนึ่งวินาที (สำหรับตัวนับช่วงเวลาหนึ่งวินาที) เครื่องมือ sleepenh ทำสิ่งนี้เพื่อคุณ

คำตอบสั้น ๆ :

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

คำอธิบาย:

ฉันรู้ว่ามีคำตอบมากมาย แต่ฉันต้องการโพสต์สิ่งที่ใกล้กับคำถามของ OP มากว่าโดยส่วนตัวฉันจะยอมรับว่าเป็น "การนับถอยหลังอัตโนมัติในเทอร์มินัล " เป้าหมายของฉันคือ:

1. หนึ่งในสายการบิน.
2. นับถอยหลัง
3. ง่ายต่อการจดจำและพิมพ์ในคอนโซล (ไม่มีฟังก์ชั่นและตรรกะหนัก, ทุบตีเท่านั้น)
4. ไม่จำเป็นต้องติดตั้งซอฟต์แวร์เพิ่มเติม (สามารถใช้กับเซิร์ฟเวอร์ใดก็ได้ที่ฉันใช้ผ่าน ssh แม้ว่าฉันจะไม่ได้รูทก็ตาม)

มันทำงานอย่างไร:

1. seq พิมพ์ตัวเลขตั้งแต่ 60 ถึง 1
2. echo -ne "\r$i "ส่งคืนคาเร็ตไปยังจุดเริ่มต้นของสตริงและพิมพ์$iค่าปัจจุบัน ช่องว่างหลังจากจำเป็นต้องเขียนทับค่าก่อนหน้าหากอักขระยาวกว่าปัจจุบัน$i(10 -> 9)

สำหรับการอ้างอิงในอนาคตมีเครื่องมือบรรทัดคำสั่งที่เรียกว่าµTimerพร้อมตัวเลือกบรรทัดคำสั่งที่ตรงไปตรงมามากสำหรับตัวจับเวลานับถอยหลัง / นับถอยหลัง

แกล้งทำเป็นว่าคุณเป็นคนใน OSX ที่กำลังมองหานาฬิกาจับเวลาบรรทัดคำสั่ง แกล้งทำเป็นว่าคุณไม่ต้องการที่จะติดตั้งเครื่องมือ gnu และเพียงต้องการที่จะทำงานกับยูนิกซ์date

ในกรณีที่ทำตามที่ @terdon พูด แต่ด้วยการปรับเปลี่ยนนี้:

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 คุณสามารถติดตั้งแพ็กเกจสำหรับหน้าจอขนาดใหญ่ ...

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'

ลองมัน!

ดูเพิ่มเติมที่http://www.cyberciti.biz/faq/create-large-colorful-text-banner-on-screen/

swเป็นนาฬิกาจับเวลาง่ายๆที่จะวิ่งไปตลอดกาล

ติดตั้ง

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

การใช้

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

ตัวอย่างไพ ธ อน:

#!/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ซึ่งเป็นเทอร์มินัลตามนาฬิกาและนาฬิกาจับเวลาที่ดี:

pip install termtime

นี่คล้ายกับคำตอบที่ยอมรับ แต่ terdon countdown()ให้ข้อผิดพลาดทางไวยากรณ์กับฉัน อันนี้ใช้งานได้ดีสำหรับฉันแม้ว่า:

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!"; }

คุณสามารถใส่มัน.bashrcแล้วดำเนินการกับ: timer t(โดยที่ t คือเวลาในหน่วยนาที)

พบคำถามก่อนหน้านี้วันนี้เมื่อค้นหาคำว่าแอปพลิเคชันเพื่อแสดงตัวนับถอยหลังขนาดใหญ่สำหรับการประชุมเชิงปฏิบัติการ ไม่มีข้อเสนอแนะใด ๆ ที่เป็นสิ่งที่ฉันต้องการดังนั้นฉันจึงรวบรวมคำแนะนำอื่น ๆ ไว้ใน Go: https://github.com/bnaucler/cdown

เมื่อคำถามได้รับคำตอบอย่างเพียงพอแล้วให้พิจารณาสิ่งนี้เพื่อประโยชน์ของลูกหลาน

$ sleep 1500 && xterm -fg เหลือง -g 240x80 &

เมื่อเทอร์มินัลตัวใหญ่ที่มีตัวอักษรสีเหลืองกระโดดขึ้นไปก็ถึงเวลาลุกขึ้นและยืด!

หมายเหตุ: - 1500 วินาที = pomodoro 25 นาที - 240x80 = ขนาดเทอร์มินัลที่มีแถวอักขระ 240 และ 80 แถว เติมหน้าจอให้ฉันอย่างเห็นได้ชัด

เครดิต: http://www.linuxquestions.org/questions/linux-newbie-8/countdown-timer-for-linux-949463/

นาฬิกาจับเวลาเวอร์ชัน GUI

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

หากคุณต้องการโปรแกรมที่คอมไพล์ด้วยเหตุผลใด ๆ ก็ตามสิ่งต่อไปนี้จะใช้ได้:

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

สามารถใช้ในโปรแกรมอื่นเช่นกันและพอร์ตได้ง่ายหากสภาพแวดล้อมทุบตีไม่พร้อมใช้งานหรือคุณเพียงต้องการใช้โปรแกรมรวบรวม

GitHub