Bagaimana saya bisa menampilkan penghitung waktu mundur real-time di terminal Linux? Apakah ada aplikasi yang ada atau, bahkan lebih baik, satu liner untuk melakukan ini?

Saya tidak yakin mengapa Anda perlu beep, jika yang Anda inginkan adalah stopwatch, Anda dapat melakukan ini:

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

Itu akan menunjukkan kepada Anda detik berlalu secara realtime dan Anda dapat menghentikannya dengan Ctrl+ C. Jika Anda membutuhkan ketelitian yang lebih besar, Anda bisa menggunakan ini untuk memberi Anda nanodetik:

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

Akhirnya, jika Anda benar-benar ingin "format stopwatch", di mana semuanya dimulai pada 0 dan mulai tumbuh, Anda bisa melakukan sesuatu seperti ini:

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

Untuk penghitung waktu mundur (yang tidak ditanyakan oleh pertanyaan awal Anda), Anda dapat melakukan ini (ubah sesuai detik):

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

Anda bisa menggabungkan ini menjadi perintah-perintah sederhana dengan menggunakan fungsi bash (atau shell mana saja yang Anda inginkan). Dalam bash, tambahkan baris-baris ini ke Anda ~/.bashrc(itu sleep 0.1akan membuat sistem menunggu 1/10 detik antara setiap kali dijalankan sehingga Anda tidak melakukan spam pada CPU Anda):

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
}

Anda kemudian dapat memulai penghitung waktu mundur satu menit dengan menjalankan:

countdown 60

Anda dapat menghitung mundur dua jam dengan:

countdown $((2*60*60))

atau sepanjang hari menggunakan:

countdown $((24*60*60))

Dan mulai stopwatch dengan menjalankan:

stopwatch

Jika Anda harus dapat berhadapan dengan hari dan juga jam, menit dan detik, Anda dapat melakukan sesuatu seperti ini:

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
}

Perhatikan bahwa stopwatchfungsi belum diuji selama berhari-hari karena saya tidak benar-benar ingin menunggu 24 jam untuk itu. Itu harus bekerja tetapi tolong beri tahu saya jika tidak.

Cara favorit saya adalah:

Mulai:

time cat

Berhenti:

ctrl+c

Seperti yang dikomentari @wjandrea di bawah ini, versi lain akan dijalankan:

time read

dan tekan Enteruntuk berhenti

Saya mencari hal yang sama dan akhirnya menulis sesuatu yang lebih rumit dengan Python:

Ini akan memberi Anda hitungan mundur 10 detik sederhana:

sudo pip install termdown
termdown 10

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

Saya sudah menggunakan yang ini:

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
)

Contoh:

 countdown "00:07:55"

Ini sumbernya .

sh-3.2# man leave

atur timer selama 15 menit

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

sunting: Saya memiliki banyak tautan terbuka, dan saya pikir ini khusus untuk osx, maaf soal itu. Meninggalkan jawaban saya sehingga orang lain sadar akan cuti pada BSD.

Ini untuk stopwatch dengan seperseratus detik:

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

Contoh

Saya telah menggabungkan jawaban terdon yang sangat bagus, ke dalam fungsi yang pada saat yang sama menampilkan waktu sejak awal, dan waktu sampai akhir. Ada juga tiga varian sehingga lebih mudah untuk dipanggil (Anda tidak harus melakukan bash matematika), dan itu juga diabstraksikan. Contoh penggunaan :

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

Dan sesuatu seperti timer kerja:

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

Dan jika Anda membutuhkan waktu yang sangat spesifik:

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

Berikut kode untuk dimasukkan ke .bashrc Anda

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

Kombinasikan ini dengan beberapa cara memutar suara di terminal linux ( memutar file mp3 atau wav melalui baris perintah Linux ) atau cygwin ( cat /path/foo.wav > /dev/dsp berfungsi untuk saya di babun / win7) dan Anda memiliki timer fleksibel sederhana dengan alarm !

Pendekatan lain

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

Untuk Mac:

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

Jika seseorang menginginkan sinyal ketika mencapai nol, misalnya ia dapat membangunnya dengan perintah yang mengembalikan status keluar bukan nol pada nol dan menggabungkannya dengan watch -b, atau sesuatu, tetapi jika seseorang ingin membangun skrip yang lebih rumit, ini mungkin bukan cara untuk pergi; ini lebih merupakan solusi tipe "cepat dan kotor".

Saya suka watchprogramnya secara umum. Saya pertama kali melihatnya setelah saya menulis while sleep 5; doloop yang tak terhitung jumlahnya untuk efek yang berbeda. watchternyata lebih bagus.

Saya akhirnya menulis skrip shell saya sendiri: 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 

Saya terkejut bahwa tidak ada yang menggunakan sleepenhalat dalam skrip mereka. Alih-alih, solusi yang diusulkan baik menggunakan sleep 1antara output timer berikutnya atau loop sibuk yang output secepat mungkin. Yang pertama tidak memadai karena karena sedikit waktu yang dihabiskan untuk melakukan pencetakan, output tidak akan benar-benar terjadi sekali per detik tetapi sedikit kurang dari apa yang suboptimal. Setelah waktu yang cukup berlalu, penghitung akan melewati satu detik. Yang terakhir tidak memadai karena membuat CPU sibuk tanpa alasan.

Alat yang saya miliki dalam $PATHpenampilan saya seperti ini:

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

Skrip dapat digunakan sebagai stop watch (menghitung hingga terputus) atau sebagai penghitung waktu yang beroperasi untuk waktu yang ditentukan. Karena sleepperintah ini digunakan, skrip ini memungkinkan untuk menentukan durasi untuk menghitung dalam ketepatan yang sama seperti yang Anda sleepizinkan. Pada Debian dan turunannya, ini termasuk tidur sub-detik dan cara yang dapat dibaca manusia untuk menentukan waktu. Jadi misalnya Anda bisa mengatakan:

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

Dan seperti yang Anda lihat, perintah berjalan tepat selama 2 menit dan 4,6 detik tanpa banyak keajaiban dalam skrip itu sendiri.

EDIT :

Alat sleepenh berasal dari paket dengan nama yang sama di Debian dan turunannya seperti Ubuntu. Untuk distribusi yang tidak memilikinya, ia berasal dari https://github.com/nsc-deb/sleepenh

Keuntungan dari sleepenh adalah, ia dapat memperhitungkan penundaan kecil yang terakumulasi dari waktu ke waktu dari pemrosesan hal-hal lain selain tidur selama satu putaran. Bahkan jika seseorang hanya sleep 1dalam satu loop 10 kali, eksekusi keseluruhan akan memakan waktu lebih dari 10 detik karena overhead kecil yang berasal dari mengeksekusi sleepdan mengulangi loop. Kesalahan ini perlahan terakumulasi dan seiring waktu akan membuat penghitung waktu stopwatch kami semakin tidak tepat. Untuk memperbaiki masalah ini, setiap iterasi harus menghitung waktu tidur yang tepat yang biasanya sedikit kurang dari satu detik (untuk timer interval satu detik). Alat sleepenh melakukan ini untuk Anda.

Jawaban singkat:

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

Penjelasan:

Saya tahu ada banyak jawaban, tetapi saya hanya ingin memposting sesuatu yang sangat dekat dengan pertanyaan OP, yang secara pribadi saya akan menerima sebagai " penghitung oneliner di terminal ". Tujuan saya adalah:

1. Satu liner
2. Hitung mundur.
3. Mudah diingat dan mengetikkan konsol (tidak ada fungsi dan logika berat, hanya bash).
4. Tidak memerlukan perangkat lunak tambahan untuk menginstal (dapat digunakan pada server mana pun saya pergi melalui ssh, bahkan jika saya tidak memiliki root di sana).

Bagaimana itu bekerja:

1. seq mencetak angka dari 60 hingga 1.
2. echo -ne "\r$i "mengembalikan tanda sisipan ke awal string dan mencetak $inilai saat ini . Spasi setelah itu diperlukan untuk menimpa nilai sebelumnya, jika lebih panjang berdasarkan karakter daripada saat ini $i(10 -> 9).

Untuk referensi di masa mendatang, ada alat baris perintah yang disebut µTimer dengan opsi baris perintah yang sangat mudah untuk penghitung waktu mundur / hitung mundur.

Berpura-puralah Anda orang di OSX mencari stopwatch baris perintah. Berpura-puralah bahwa Anda tidak ingin menginstal alat gnu dan hanya ingin menjalankan dengan unixdate

dalam hal ini lakukan seperti yang dikatakan @terdon tetapi dengan modifikasi ini:

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

Cukup gunakan tanggal + jam dalam waktu UTC. Anda juga dapat menginstal beberapa paket untuk tampilan besar ...

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'

Cobalah!

Lihat juga http://www.cyberciti.biz/faq/create-large-colorful-text-banner-on-screen/

sw adalah stopwatch sederhana yang akan berjalan selamanya.

Pasang

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

Pemakaian

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

Contoh python:

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

Lihatlah TermTime , ini adalah jam dan stopwatch berbasis terminal yang bagus:

pip install termtime

Ini mirip dengan jawaban yang diterima, tetapi terdon countdown()memberi saya kesalahan sintaks. Yang ini sangat bagus untuk saya, meskipun:

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

Anda dapat memasukkannya ke dalam .bashrcdan kemudian jalankan dengan: timer t(di mana t adalah waktu dalam menit).

Temukan pertanyaan ini sebelumnya hari ini, ketika mencari aplikasi istilah untuk menampilkan penghitung waktu mundur yang besar untuk sebuah lokakarya. Tidak ada saran yang persis apa yang saya butuhkan, jadi saya segera memasukkan satu lagi di Go: https://github.com/bnaucler/cdown

Karena pertanyaannya sudah dijawab dengan cukup, anggap ini demi anak cucu.

$ sleep 1500 && xterm -fg yellow -g 240x80 &

Ketika terminal besar dengan teks kuning itu melompat, saatnya bangun dan meregang!

Catatan: - 1500 detik = 25 menit pomodoro - 240x80 = ukuran terminal dengan 240 karakter baris, dan 80 baris. Mengisi layar untuk saya secara nyata.

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

Versi GUI dari stopwatch

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

Jika Anda menginginkan program yang dapat dikompilasi dengan alasan apa pun, berikut ini akan berfungsi:

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

Ini dapat digunakan dalam program lain juga dan mudah dipindahkan, jika lingkungan bash tidak tersedia atau Anda lebih suka menggunakan program yang dikompilasi

github