दिलचस्प पोस्ट
हैशमैप में प्रविष्टि ऑर्डर कैसे सुरक्षित रखना है? Preg_replace में html टैगों को अनदेखा करें जावा में मुख्य थ्रेड स्टॉप कब करता है? ASP.NET MS11-100: मैं पोस्ट किए गए फार्म मूल्यों की अधिकतम संख्या को कैसे बदल सकता हूँ? पायथन नियमित अभिव्यक्ति – एक वाइल्डकार्ड अभिव्यक्ति से कई समूहों को कैसे कैप्चर करना है? जावास्क्रिप्ट में, आप DOM का विस्तार कर सकते हैं? जेपीए और सीतनिद्रा में होना का उपयोग कर आलियाई प्रारंभिकरण को हल करने के लिए कैसे करें MySQL अद्यतन क्वेरी पर 'फ़ील्ड सूची' त्रुटि में अज्ञात स्तंभ ListView setOnItemClickListener बटन जोड़कर काम नहीं कर रहा है एक सरणी में डुप्लिकेट ढूंढें स्क्रीन अभिलेखी क्या मैं माता-पिता के सापेक्ष एक तत्व तय कर सकता हूं? फ़ायरबसे सुरक्षा नियमों के साथ सार्वजनिक / निजी उपयोगकर्ता प्रोफ़ाइल कैसे बनाएं? नक्शा बनाम ऑब्जेक्ट में जावास्क्रिप्ट जावास्क्रिप्ट के साथ एचटीएमएल तत्व डालना

शैल लिपि में प्रगति पट्टी कैसे जोड़ सकते हैं?

जब बेसिक या किसी अन्य शेल में स्क्रिप्टिंग * एनआईएक्स में, एक कमांड चलाने पर कुछ सेकेंड से अधिक समय लगेगा, तो एक प्रगति पट्टी की आवश्यकता है।

उदाहरण के लिए, एक बड़ी फ़ाइल की प्रतिलिपि बनाने के लिए, एक बड़ी टार फाइल खोलना

आप किन तरीकों से शेल लिपियों को प्रगति सलाखों को जोड़ने की सलाह देते हैं?

वेब के समाधान से एकत्रित समाधान "शैल लिपि में प्रगति पट्टी कैसे जोड़ सकते हैं?"

आप इसे एक लाइन को ओवरराइट करके लागू कर सकते हैं टर्मिनल पर \n लिखने के बिना लाइन की शुरुआत में वापस जाने के लिए \r का उपयोग करें।

जब आप लाइन को अग्रिम करने के लिए पूरा कर लें \n लिखें

echo -ne का प्रयोग करें:

  1. मुद्रित नहीं \n और
  2. एस्केप अनुक्रमों को पहचानने के लिए जैसे \r

यहां एक डेमो है:

 echo -ne '##### (33%)\r' sleep 1 echo -ne '############# (66%)\r' sleep 1 echo -ne '####################### (100%)\r' echo -ne '\n' 

कुछ पदों ने दिखाया है कि कमांड की प्रगति कैसे प्रदर्शित होगी। इसे गणना करने के लिए, आपको यह देखना होगा कि आपने कितना प्रगति की है बीएसडी सिस्टम पर कुछ आज्ञाएं, जैसे कि डीडी (1), एक SIGINFO संकेत स्वीकार करते हैं, और उनकी प्रगति की रिपोर्ट करेंगे। लिनक्स सिस्टम पर कुछ कमांड SIGUSR1 समान प्रतिक्रिया SIGUSR1 । यदि यह सुविधा उपलब्ध है, तो आप संसाधित बाइट्स की संख्या की निगरानी के लिए dd माध्यम से अपना इनपुट पाइप कर सकते हैं।

वैकल्पिक रूप से, आप फ़ाइल के पढ़ने के सूचक की ऑफसेट प्राप्त करने के लिए lsof का उपयोग कर सकते हैं, और इस प्रकार प्रगति की गणना कर सकते हैं। मैंने एक कमांड नामित किया है, नामित टेलिफोनर , जो एक विशिष्ट प्रक्रिया या फ़ाइल को प्रसंस्करण की प्रगति दिखाता है इसके साथ आप कुछ कर सकते हैं, जैसे निम्नलिखित

 $ pmonitor -c gzip /home/dds/data/mysql-2015-04-01.sql.gz 58.06% 

मेरे ब्लॉग पर लिनक्स और फ्रीबीएसएप खोल स्क्रिप्ट का एक पूर्व संस्करण दिखाई देता है

आप भी स्पिनर कैसे कर सकते हैं :

क्या मैं बाश में स्पिनर कर सकता हूं?

ज़रूर!

 i=1 sp="/-\|" echo -n ' ' while true do printf "\b${sp:i++%${#sp}:1}" done 

हर बार लूप पुनरावृत्त करता है, यह अगले अक्षर को सपा स्ट्रिंग में दिखाता है, जब वह अंत तक पहुंचता है। (मैं प्रदर्शित करने के लिए वर्तमान चरित्र की स्थिति और $ {# sp} एसपी स्ट्रिंग की लंबाई है)।

\ B स्ट्रिंग को एक 'बैकस्पेस' वर्ण से बदल दिया गया है वैकल्पिक रूप से, आप लाइन के आरंभ में वापस जाने के लिए \ r के साथ खेल सकते हैं

यदि आप इसे धीमा करना चाहते हैं, तो लूप के अंदर नींद कमांड डालकर (printf के बाद)।

एक POSIX बराबर होगा:

 sp='/-\|' printf ' ' while true; do printf '\b%.1s' "$sp" sp=${sp#?}${sp%???} done 

यदि आपके पास पहले से बहुत कुछ काम करता है, तो आप स्पिनर को अपडेट करने के लिए प्रत्येक आवृत्ति की शुरुआत में निम्न फ़ंक्शन कॉल कर सकते हैं:

 sp="/-\|" sc=0 spin() { printf "\b${sp:sc++:1}" ((sc==${#sp})) && sc=0 } endspin() { printf "\r%s\n" "$@" } until work_done; do spin some_work ... done endspin 

linux कमांड पीवी का उपयोग करें:

http://linux.die.net/man/1/pv

यह आकार के बारे में नहीं जानता है, यदि यह धारा के मध्य में है, लेकिन यह गति और कुल देता है और वहां से आप समझ सकते हैं कि यह कब तक लेना चाहिए और फीडबैक प्राप्त करें ताकि आपको पता चले कि यह लटका नहीं है।

एक आसान प्रगति बार समारोह है जो मैंने दूसरे दिन लिखा था:

 #!/bin/bash # 1. Create ProgressBar function # 1.1 Input is currentState($1) and totalState($2) function ProgressBar { # Process data let _progress=(${1}*100/${2}*100)/100 let _done=(${_progress}*4)/10 let _left=40-$_done # Build progressbar string lengths _fill=$(printf "%${_done}s") _empty=$(printf "%${_left}s") # 1.2 Build progressbar strings and print the ProgressBar line # 1.2.1 Output example: # 1.2.1.1 Progress : [########################################] 100% printf "\rProgress : [${_fill// /#}${_empty// /-}] ${_progress}%%" } # Variables _start=1 # This accounts as the "totalState" variable for the ProgressBar function _end=100 # Proof of concept for number in $(seq ${_start} ${_end}) do sleep 0.1 ProgressBar ${number} ${_end} done printf '\nFinished!\n' 

या इसे से लपेटें,
https://github.com/fearside/ProgressBar/

जीएनयू टैर एक उपयोगी विकल्प है जो एक सरल प्रगति बार की कार्यक्षमता देता है।

(…) एक और उपलब्ध चेकपॉइंट कार्रवाई 'डॉट' (या '।') है यह मानक सूची स्ट्रीम पर एक एकल बिंदु को मुद्रित करने के लिए टार को निर्देश देता है, उदाहरण के लिए:

 $ tar -c --checkpoint=1000 --checkpoint-action=dot /var ... 

उसी प्रभाव से प्राप्त किया जा सकता है:

 $ tar -c --checkpoint=.1000 /var 

एक आसान तरीका जो कि मेरे सिस्टम पर पाइपव्यूव्यू (पीवी) उपयोगिता का उपयोग करता है

 srcdir=$1 outfile=$2 tar -Ocf - $srcdir | pv -i 1 -w 50 -berps `du -bs $srcdir | awk '{print $1}'` | 7za a -si $outfile 

मैं चुने हुए उत्तर से ज्यादा कामुक लग रहा था, इसलिए मेरी अपनी स्क्रिप्ट भी थी

पूर्वावलोकन

कार्यवाही में प्रगति- bar.sh

स्रोत

मैं इसे गिटब प्रगति- bar.sh पर डाल दिया

 progress-bar() { local duration=${1} already_done() { for ((done=0; done<$elapsed; done++)); do printf "▇"; done } remaining() { for ((remain=$elapsed; remain<$duration; remain++)); do printf " "; done } percentage() { printf "| %s%%" $(( (($elapsed)*100)/($duration)*100/100 )); } clean_line() { printf "\r"; } for (( elapsed=1; elapsed<=$duration; elapsed++ )); do already_done; remaining; percentage sleep 1 clean_line done clean_line } 

प्रयोग

 progress 100 

यह आपको विज़ुअलाइज़ करने देता है कि एक कमांड अभी निष्पादित है:

 while :;do echo -n .;sleep 1;done & trap "kill $!" EXIT #Die with parent if we die prematurely tar zxf packages.tar.gz; # or any other command here kill $! && trap " " EXIT #Kill the loop and unset the trap or else the pid might get reassigned and we might end up killing a completely different process 

यह एक अनन्त बना देगा, जबकि लूप पृष्ठभूमि में कार्यान्वित होगा और "।" हर पल। यह प्रदर्शित होगा खोल में tar कमांड या किसी भी कमांड को आप चाहते हैं जब यह आदेश निष्पादित करना समाप्त हो जाता है, तो पृष्ठभूमि में चल रहे आखिरी नौकरी को मार डालें – जो अनंत है जबकि लूप

सबसे पहले, केवल एक पाइप प्रगति मीटर नहीं है। दूसरा (शायद अधिक ज्ञात भी) पीवी (पाइप व्यूअर) है

दूसरे बार और पीवी का उपयोग उदाहरण के लिए किया जा सकता है:

 $ bar file1 | wc -l $ pv file1 | wc -l 

या और भी:

 $ tail -n 100 file1 | bar | wc -l $ tail -n 100 file1 | pv | wc -l 

एक उपयोगी चाल यदि आप कमांड में दिए गए फाइलों के साथ बार और पीवी का उपयोग करना चाहते हैं, जैसे कि फाइल में file1 file2, जैसे प्रक्रिया प्रतिस्थापन का उपयोग करना है :

 $ copy <(bar file1) file2 $ copy <(pv file1) file2 

प्रोसेस प्रतिस्थापन एक बैश जादू चीज है जो अस्थायी फीफो पाइप फाइलों / dev / fd / बनाता है और इस पाइप के माध्यम से runned प्रक्रिया (कोष्ठक के अंदर) से stdout कनेक्ट करती है और इसे एक साधारण फ़ाइल की तरह देखता है (एक अपवाद के साथ, यह केवल इसे पढ़ सकता है फारवर्ड)।

अद्यतन करें:

बार कमांड स्वतः ही नकल के लिए भी अनुमति देता है। मैन बार के बाद:

 bar --in-file /dev/rmt/1cbn --out-file \ tape-restore.tar --size 2.4g --buffer-size 64k 

लेकिन प्रक्रिया प्रतिस्थापन मेरे विचार में है और ऐसा करने के लिए अधिक सामान्य तरीका है। यह सीपी प्रोग्राम का उपयोग करता है

ऐसा कुछ भी नहीं देखा है … मेरा बहुत सरल समाधान:

 #!/bin/bash BAR='####################' # this is full bar, mine is 20 chars for i in {1..20}; do echo -ne "\r${BAR:0:$i}" # print $i chars of $BAR from 0 position sleep .1 done 
  • echo -n – अंत में नई लाइन के बिना प्रिंट करें
  • echo -e – मुद्रण करते समय विशेष वर्णों का स्पष्टीकरण
  • "\r" – कैरिएस रिटर्न, एक विशेष चार लाइन की शुरुआत में लौटने के लिए

मैं लंबे समय से पहले एक सरल "हैकिंग वीडियो" में टाइपिंग कोड अनुकरण करने के लिए उपयोग किया था। 😉

अधिकांश यूनिक्स कमांड आपको ऐसी सीधी प्रतिक्रिया नहीं देंगे, जिससे आप यह कर सकते हैं। कुछ आपको stdout या stderr पर आउटपुट देंगे जो आप उपयोग कर सकते हैं।

टार की तरह कुछ के लिए आप-वी स्विच का इस्तेमाल कर सकते हैं और एक प्रोग्राम को आउटपुट पाइप कर सकते हैं जो प्रत्येक लाइन के लिए छोटे एनीमेशन को अपडेट करता है। जैसे टार फाइलों की एक सूची लिखता है, जिसने इसे सुलझाया है, वह एनीमेशन अपडेट कर सकता है। एक प्रतिशत पूर्ण करने के लिए आपको फाइलों की संख्या जानना होगा और लाइनों की गणना करना होगा।

सीपी इस तरह की आउटपुट को तब तक नहीं देता जितना मुझे पता है। सीपी की प्रगति की निगरानी के लिए आपको स्रोत और गंतव्य फाइलों की निगरानी करना होगा और गंतव्य के आकार को देखना होगा। फ़ाइल आकार पाने के लिए आप stat (2) सिस्टम कॉल का उपयोग करके एक छोटा सा प्रोग्राम लिख सकते हैं। यह स्रोत के आकार को पढ़ने के बाद गंतव्य फ़ाइल को चुनाव करेगा और तारीख को लिखे गए फ़ाइल के आकार के आधार पर% पूर्ण बार अपडेट करेगा।

मेरा समाधान वर्तमान में टारबॉल का प्रतिशत दिखाता है जो वर्तमान में असंपीड़ित और लिखित है। मैं इसका उपयोग करते समय 2 जीबी रूट फाइलसिस्टम छवियों को लिखता हूं। आपको वास्तव में इन बातों के लिए प्रगति बार की आवश्यकता है gzip --list की कुल असम्पीडेड आकार पाने के लिए मैं क्या कर रहा हूँ gzip --list का उपयोग करें उस पर से मैं ब्लॉकिंग-कारक को 100 भागों में विभाजित करने के लिए आवश्यक गणना करता हूं। अंत में, मैं प्रत्येक ब्लॉक के लिए एक चेकपॉइंट संदेश प्रिंट करता हूं I 2 जीबी फ़ाइल के लिए यह 10 एमबी ब्लॉक देता है यदि यह बहुत बड़ा है तो आप 10 या 100 तक BLOCKING_FACTOR को विभाजित कर सकते हैं, लेकिन फिर प्रतिशत के मामले में सुंदर आउटपुट प्रिंट करना कठिन है।

मान लें कि आप बैश का उपयोग कर रहे हैं तो आप निम्न शेल फ़ंक्शन का उपयोग कर सकते हैं

 untar_progress () { TARBALL=$1 BLOCKING_FACTOR=$(gzip --list ${TARBALL} | perl -MPOSIX -ane '$.==2 && print ceil $F[1]/50688') tar --blocking-factor=${BLOCKING_FACTOR} --checkpoint=1 \ --checkpoint-action='ttyout=Wrote %u% \r' -zxf ${TARBALL} } 

मैं गोग परम के साथ संवाद का उपयोग करना पसंद करता हूं । बहुत अक्सर .deb पैकेज प्रतिष्ठानों और कई बुनियादी विन्यास सामानों का उपयोग किया जाता है। तो आपको पहिया को फिर से बदलने की ज़रूरत नहीं है … फिर से

बस 1 से 100 @stdin पर एक पूर्णांक मान डाल दें। एक बुनियादी और मूर्खतापूर्ण उदाहरण:

 for a in {1..100}; do sleep .1s; echo $a| dialog --gauge "waiting" 7 30; done 

खाना पकाने के प्रयोजनों के लिए मेरे पास इस / बिन / प्रतीक्षा फ़ाइल है (चम्मोड यू + एक्स पर्म) के साथ: पी

 #!/bin/bash INIT=`/bin/date +%s` NOW=$INIT FUTURE=`/bin/date -d "$1" +%s` [ $FUTURE -a $FUTURE -eq $FUTURE ] || exit DIFF=`echo "$FUTURE - $INIT"|bc -l` while [ $INIT -le $FUTURE -a $NOW -lt $FUTURE ]; do NOW=`/bin/date +%s` STEP=`echo "$NOW - $INIT"|bc -l` SLEFT=`echo "$FUTURE - $NOW"|bc -l` MLEFT=`echo "scale=2;$SLEFT/60"|bc -l` TEXT="$SLEFT seconds left ($MLEFT minutes)"; TITLE="Waiting $1: $2" sleep 1s PTG=`echo "scale=0;$STEP * 100 / $DIFF"|bc -l` echo $PTG| dialog --title "$TITLE" --gauge "$TEXT" 7 72 done if [ "$2" == "" ]; then msg="Espera terminada: $1";audio="Listo"; else msg=$2;audio=$2;fi /usr/bin/notify-send --icon=stock_appointment-reminder-excl "$msg" espeak -v spanish "$audio" 

तो मैं डाल सकता हूँ:

Wait "34 min" "warm up the oven"

या

Wait "dec 31" "happy new year"

मैं अपनी स्वयं की प्रगति बार को भी योगदान देना चाहूंगा

यह आधा यूनिकोड ब्लॉकों का उपयोग करके उप-चरित्र परिशुद्धता प्राप्त करता है

यहां छवि विवरण दर्ज करें

कोड शामिल है

मेरे लिए सबसे आसान उपयोग करने के लिए और अब तक सबसे अच्छा लग रहा है कमांड pv या कुछ आदमी पहले ही लिखा है जैसे bar

उदाहरण के लिए: dd साथ पूरे ड्राइव का बैकअप बनाने की आवश्यकता है

आम तौर पर आप dd if="$input_drive_path" of="$output_file_path" उपयोग करते हैं dd if="$input_drive_path" of="$output_file_path"

pv साथ आप इसे इस तरह बना सकते हैं:

dd if="$input_drive_path" | pv | dd of="$output_file_path"

और प्रगति सीधे STDOUT जाती है:

  7.46GB 0:33:40 [3.78MB/s] [ <=> ] 

इसे पूरा होने के बाद सारांश आता है

  15654912+0 records in 15654912+0 records out 8015314944 bytes (8.0 GB) copied, 2020.49 s, 4.0 MB/s 

गतिविधि की प्रगति इंगित करने के लिए, निम्न आदेशों का प्रयास करें:

 while true; do sleep 0.25 && echo -ne "\r\\" && sleep 0.25 && echo -ne "\r|" && sleep 0.25 && echo -ne "\r/" && sleep 0.25 && echo -ne "\r-"; done; 

या

 while true; do sleep 0.25 && echo -ne "\rActivity: \\" && sleep 0.25 && echo -ne "\rActivity: |" && sleep 0.25 && echo -ne "\rActivity: /" && sleep 0.25 && echo -ne "\rActivity: -"; done; 

या

 while true; do sleep 0.25 && echo -ne "\r" && sleep 0.25 && echo -ne "\r>" && sleep 0.25 && echo -ne "\r>>" && sleep 0.25 && echo -ne "\r>>>"; sleep 0.25 && echo -ne "\r>>>>"; done; 

या

 while true; do sleep .25 && echo -ne "\r:Active:" && sleep .25 && echo -ne "\r:aCtive:" && sleep .25 && echo -ne "\r:acTive:" && sleep .25 && echo -ne "\r:actIve:" && sleep .25 && echo -ne "\r:actiVe:" && sleep .25 && echo -ne "\r:activE:"; done; 

कोई भी झंडे / वेरिएबल्स का प्रयोग कर सकता है, जबकि लूप की जांच के लिए और प्रगति के मूल्य / सीमा को प्रदर्शित करता है।

मैं चार बार दोहराए जाने के लिए शैल स्क्रिप्ट में दोहराए गए वर्णों की स्ट्रिंग बनाने से एक उत्तर का उपयोग किया। मेरे पास स्क्रिप्ट के लिए दो अपेक्षाकृत छोटे बास संस्करण हैं, जिन्हें प्रगति बार प्रदर्शित करने की आवश्यकता होती है (उदाहरण के लिए, एक लूप जो कई फाइलों में जाती है, लेकिन बड़ी रर फ़ाइलों या प्रतिलिपि संचालन के लिए उपयोगी नहीं)। तेजी से एक में दो फ़ंक्शन होते हैं, एक बार बार प्रदर्शन के लिए तार तैयार करने के लिए:

 preparebar() { # $1 - bar length # $2 - bar char barlen=$1 barspaces=$(printf "%*s" "$1") barchars=$(printf "%*s" "$1" | tr ' ' "$2") } 

और एक प्रगति पट्टी प्रदर्शित करने के लिए:

 progressbar() { # $1 - number (-1 for clearing the bar) # $2 - max number if [ $1 -eq -1 ]; then printf "\r $barspaces\r" else barch=$(($1*barlen/$2)) barsp=$((barlen-barch)) printf "\r[%.${barch}s%.${barsp}s]\r" "$barchars" "$barspaces" fi } 

इसका इस्तेमाल इस प्रकार किया जा सकता है:

 preparebar 50 "#" 

जिसका अर्थ है कि 50 "#" वर्णों के साथ बार के लिए स्ट्रिंग तैयार करें, और उसके बाद:

 progressbar 35 80 

"#" वर्णों की संख्या जो कि 35/80 अनुपात से मेल खाती है, प्रदर्शित करेगा:

 [##################### ] 

ध्यान रखें कि जब तक आप (या कोई अन्य प्रोग्राम) एक नई लाइन प्रिंट नहीं करते, तब तक फ़ंक्शन एक ही लाइन पर बार और अधिक प्रदर्शित करता है यदि आप 1 को पहले पैरामीटर के रूप में डालते हैं, तो बार मिटा दिया जाएगा:

 progressbar -1 80 

धीमी संस्करण सभी एक फ़ंक्शन में है:

 progressbar() { # $1 - number # $2 - max number # $3 - number of '#' characters if [ $1 -eq -1 ]; then printf "\r %*s\r" "$3" else i=$(($1*$3/$2)) j=$(($3-i)) printf "\r[%*s" "$i" | tr ' ' '#' printf "%*s]\r" "$j" fi } 

और इसका प्रयोग (जैसा ऊपर दिखाया गया है):

 progressbar 35 80 50 

यदि आप stderr पर progressbar की जरूरत है, तो बस प्रत्येक प्रिंटफ कमांड के अंत में >&2 जोड़ें

बहुत सारे उत्तर '\r' + $some_sort_of_progress_msg को छपाई करने के लिए अपने खुद के आदेशों का वर्णन करने का वर्णन करते हैं कभी-कभी समस्या यह है कि प्रति सेकंड सैकड़ों इन अपडेट्स को प्रिंट करना प्रक्रिया को धीमा कर देगा

हालांकि, अगर आपकी कोई भी प्रक्रिया आउटपुट उत्पादन करती है (जैसे 7z a -r newZipFile myFolder प्रत्येक फ़ाइल नाम के रूप में इसे संपीड़ित करेगा) तो एक सरल, तेज़, दर्द रहित और अनुकूलन योग्य समाधान मौजूद होगा।

अजगर मॉड्यूल tqdm स्थापित करें

 $ sudo pip install tqdm $ # now have fun $ 7z a -r -bd newZipFile myFolder | tqdm >> /dev/null $ # if we know the expected total, we can have a bar! $ 7z a -r -bd newZipFile myFolder | grep -o Compressing | tqdm --total $(find myFolder -type f | wc -l) >> /dev/null 

सहायता: tqdm -h अधिक विकल्पों का उपयोग करते हुए एक उदाहरण:

 $ find / -name '*.py' -exec cat \{} \; | tqdm --unit loc --unit_scale True | wc -l 

बोनस के रूप में आप tqdm को पायथन कोड में लपेटने के लिए भी tqdm का उपयोग कर सकते हैं।

https://github.com/tqdm/tqdm/blob/master/README.rst#module

एडॉआर्ड लोपेज़ के काम के आधार पर, मैंने एक प्रगति पट्टी बनाई जो कि स्क्रीन के आकार में फिट बैठती है, चाहे जो भी हो। इसकी जांच – पड़ताल करें।

यहां छवि विवरण दर्ज करें

यह गिट हब पर भी पोस्ट किया गया है

 #!/bin/bash # # Progress bar by Adriano Pinaffo # Available at https://github.com/adriano-pinaffo/progressbar.sh # Inspired on work by Edouard Lopez (https://github.com/edouard-lopez/progress-bar.sh) # Version 1.0 # Date April, 28th 2017 function error { echo "Usage: $0 [SECONDS]" case $1 in 1) echo "Pass one argument only" exit 1 ;; 2) echo "Parameter must be a number" exit 2 ;; *) echo "Unknown error" exit 999 esac } [[ $# -ne 1 ]] && error 1 [[ $1 =~ ^[0-9]+$ ]] || error 2 duration=${1} barsize=$((`tput cols` - 7)) unity=$(($barsize / $duration)) increment=$(($barsize%$duration)) skip=$(($duration/($duration-$increment))) curr_bar=0 prev_bar= for (( elapsed=1; elapsed<=$duration; elapsed++ )) do # Elapsed prev_bar=$curr_bar let curr_bar+=$unity [[ $increment -eq 0 ]] || { [[ $skip -eq 1 ]] && { [[ $(($elapsed%($duration/$increment))) -eq 0 ]] && let curr_bar++; } || { [[ $(($elapsed%$skip)) -ne 0 ]] && let curr_bar++; } } [[ $elapsed -eq 1 && $increment -eq 1 && $skip -ne 1 ]] && let curr_bar++ [[ $(($barsize-$curr_bar)) -eq 1 ]] && let curr_bar++ [[ $curr_bar -lt $barsize ]] || curr_bar=$barsize for (( filled=0; filled<=$curr_bar; filled++ )); do printf "▇" done # Remaining for (( remain=$curr_bar; remain<$barsize; remain++ )); do printf " " done # Percentage printf "| %s%%" $(( ($elapsed*100)/$duration)) # Return sleep 1 printf "\r" done printf "\n" exit 0 

का आनंद लें

यह केवल gnome zenity का उपयोग कर लागू होता है स्क्रिप्ट्स को मारने के लिए ज़ेनिटी एक महान मूल इंटरफ़ेस प्रदान करता है: https://help.gnome.org/users/zenity/stable/

ज़ेनिटी प्रगति बार उदाहरण से:

 #!/bin/sh ( echo "10" ; sleep 1 echo "# Updating mail logs" ; sleep 1 echo "20" ; sleep 1 echo "# Resetting cron jobs" ; sleep 1 echo "50" ; sleep 1 echo "This line will just be ignored" ; sleep 1 echo "75" ; sleep 1 echo "# Rebooting system" ; sleep 1 echo "100" ; sleep 1 ) | zenity --progress \ --title="Update System Logs" \ --text="Scanning mail logs..." \ --percentage=0 if [ "$?" = -1 ] ; then zenity --error \ --text="Update canceled." fi 

मैंने एक एम्बेडेड सिस्टम के लिए एक शुद्ध शैल संस्करण बनाया है:

  • / usr / bin / dd sIGUSR1 संकेत हैंडलिंग सुविधा

    असल में, यदि आप 'मार SIGUSR1 $ (pid_of_running_dd_process)' भेजते हैं, तो यह आउटपुट गति का सारांश और ट्रांसफर की गई राशि का उत्पादन करेगा।

  • पृष्ठभूमि डीडी और फिर अपडेट के लिए इसे नियमित रूप से पूछताछ करना, और पुराने स्कूल एफ़टीपी क्लाइंट जैसे हेश टिकी बनाना

  • Non-stdout के अनुकूल प्रोग्राम जैसे scp के लिए गंतव्य के रूप में / dev / stdout का उपयोग करना

अंतिम परिणाम आपको किसी भी फाइल ट्रांसफर ऑपरेशन को लेने और प्रगति अपडेट प्राप्त करने की अनुमति देता है जो पुरानी-स्कूल एफ़टीपी 'हैश' आउटपुट की तरह दिखता है जहां आपको हर एक्स बाइट के लिए एक हैश चिह्न मिलता है।

यह शायद ही उत्पादन गुणवत्ता कोड है, लेकिन आपको यह विचार मिलता है। मुझे लगता है कि यह प्यारा है

क्या इसके लायक है, हेट की संख्या में वास्तविक बाइट-गिनती ठीक से प्रदर्शित नहीं हो सकती है – आपके पास गोलाकार मुद्दों के आधार पर एक या उससे कम हो सकता है एक परीक्षण स्क्रिप्ट के भाग के रूप में इसका उपयोग न करें, यह सिर्फ आंख-कैंडी है और, हाँ, मुझे पता है कि यह बहुत ही अक्षम है – यह एक खोल स्क्रिप्ट है और मैं इसके लिए कोई क्षमा नहीं करता।

अंत में प्रदान की गई wget, scp और tftp के साथ उदाहरण यह कुछ भी है जो डेटा का उत्सर्जन करता है के साथ काम करना चाहिए। प्रोग्राम के लिए / dev / stdout का उपयोग करना सुनिश्चित करें जो stdout के अनुकूल नहीं हैं

 #!/bin/sh # # Copyright (C) Nathan Ramella (nar+progress-script@remix.net) 2010 # LGPLv2 license # If you use this, send me an email to say thanks and let me know what your product # is so I can tell all my friends I'm a big man on the internet! progress_filter() { local START=$(date +"%s") local SIZE=1 local DURATION=1 local BLKSZ=51200 local TMPFILE=/tmp/tmpfile local PROGRESS=/tmp/tftp.progress local BYTES_LAST_CYCLE=0 local BYTES_THIS_CYCLE=0 rm -f ${PROGRESS} dd bs=$BLKSZ of=${TMPFILE} 2>&1 \ | grep --line-buffered -E '[[:digit:]]* bytes' \ | awk '{ print $1 }' >> ${PROGRESS} & # Loop while the 'dd' exists. It would be 'more better' if we # actually looked for the specific child ID of the running # process by identifying which child process it was. If someone # else is running dd, it will mess things up. # My PID handling is dumb, it assumes you only have one running dd on # the system, this should be fixed to just get the PID of the child # process from the shell. while [ $(pidof dd) -gt 1 ]; do # PROTIP: You can sleep partial seconds (at least on linux) sleep .5 # Force dd to update us on it's progress (which gets # redirected to $PROGRESS file. # # dumb pid handling again pkill -USR1 dd local BYTES_THIS_CYCLE=$(tail -1 $PROGRESS) local XFER_BLKS=$(((BYTES_THIS_CYCLE-BYTES_LAST_CYCLE)/BLKSZ)) # Don't print anything unless we've got 1 block or more. # This allows for stdin/stderr interactions to occur # without printing a hash erroneously. # Also makes it possible for you to background 'scp', # but still use the /dev/stdout trick _even_ if scp # (inevitably) asks for a password. # # Fancy! if [ $XFER_BLKS -gt 0 ]; then printf "#%0.s" $(seq 0 $XFER_BLKS) BYTES_LAST_CYCLE=$BYTES_THIS_CYCLE fi done local SIZE=$(stat -c"%s" $TMPFILE) local NOW=$(date +"%s") if [ $NOW -eq 0 ]; then NOW=1 fi local DURATION=$(($NOW-$START)) local BYTES_PER_SECOND=$(( SIZE / DURATION )) local KBPS=$((SIZE/DURATION/1024)) local MD5=$(md5sum $TMPFILE | awk '{ print $1 }') # This function prints out ugly stuff suitable for eval() # rather than a pretty string. This makes it a bit more # flexible if you have a custom format (or dare I say, locale?) printf "\nDURATION=%d\nBYTES=%d\nKBPS=%f\nMD5=%s\n" \ $DURATION \ $SIZE \ $KBPS \ $MD5 } 

उदाहरण:

 echo "wget" wget -q -O /dev/stdout http://www.blah.com/somefile.zip | progress_filter echo "tftp" tftp -l /dev/stdout -g -r something/firmware.bin 192.168.1.1 | progress_filter echo "scp" scp user@192.168.1.1:~/myfile.tar /dev/stdout | progress_filter 

मैंने डर से दिए गए उत्तर पर बनाया है

यह एक आरएमएएन पुनर्स्थापना की प्रगति को पुनर्प्राप्त करने के लिए ओरेकल डेटाबेस से कनेक्ट करता है।

 #!/bin/bash # 1. Create ProgressBar function # 1.1 Input is currentState($1) and totalState($2) function ProgressBar { # Process data let _progress=(${1}*100/${2}*100)/100 let _done=(${_progress}*4)/10 let _left=40-$_done # Build progressbar string lengths _fill=$(printf "%${_done}s") _empty=$(printf "%${_left}s") # 1.2 Build progressbar strings and print the ProgressBar line # 1.2.1 Output example: # 1.2.1.1 Progress : [########################################] 100% printf "\rProgress : [${_fill// /#}${_empty// /-}] ${_progress}%%" } function rman_check { sqlplus -s / as sysdba <<EOF set heading off set feedback off select round((sofar/totalwork) * 100,0) pct_done from v\$session_longops where totalwork > sofar AND opname NOT LIKE '%aggregate%' AND opname like 'RMAN%'; exit EOF } # Variables _start=1 # This accounts as the "totalState" variable for the ProgressBar function _end=100 _rman_progress=$(rman_check) #echo ${_rman_progress} # Proof of concept #for number in $(seq ${_start} ${_end}) while [ ${_rman_progress} -lt 100 ] do for number in _rman_progress do sleep 10 ProgressBar ${number} ${_end} done _rman_progress=$(rman_check) done printf '\nFinished!\n' 

यह एनएक्सस द्वारा बास स्क्रिप्टिंग के लिए साइकेडेलिक प्रोग्रेसबार है। यह कमांड लाइन से './progressbar xy' के रूप में कहा जा सकता है जहां 'x' सेकंड में एक समय है और 'y' एक प्रगति के उस भाग से संबंधित संदेश है।

आंतरिक प्रगति पट्टी () फ़ंक्शन ही अच्छा स्वसंपूर्ण है यदि आप अपनी स्क्रिप्ट के अन्य भागों को प्रगति पट्टी को नियंत्रित करने के लिए चाहते हैं। उदाहरण के लिए, 'प्रगति पट्टी 10' निर्देशिका पेड़ बनाना; ";" प्रदर्शित होगा:

 [####### ] (10%) Creating directory tree 

बेशक यह अच्छी तरह से साइकेडेलिक होगा …

 #!/bin/bash if [ "$#" -eq 0 ]; then echo "x is \"time in seconds\" and z is \"message\""; echo "Usage: progressbar xz"; exit; fi progressbar() { local loca=$1; local loca2=$2; declare -a bgcolors; declare -a fgcolors; for i in {40..46} {100..106}; do bgcolors+=("$i") done for i in {30..36} {90..96}; do fgcolors+=("$i") done local u=$(( 50 - loca )); local y; local t; local z; z=$(printf '%*s' "$u"); local w=$(( loca * 2 )); local bouncer=".oO°Oo."; for ((i=0;i<loca;i++)); do t="${bouncer:((i%${#bouncer})):1}" bgcolor="\\E[${bgcolors[RANDOM % 14]}m \\033[m" y+="$bgcolor"; done fgcolor="\\E[${fgcolors[RANDOM % 14]}m" echo -ne " $fgcolor$t$y$z$fgcolor$t \\E[96m(\\E[36m$w%\\E[96m)\\E[92m $fgcolor$loca2\\033[m\r" }; timeprogress() { local loca="$1"; local loca2="$2"; loca=$(bc -l <<< scale=2\;"$loca/50") for i in {1..50}; do progressbar "$i" "$loca2"; sleep "$loca"; done printf "\n" }; timeprogress "$1" "$2" 

सबसे पहले पृष्ठभूमि की प्रक्रिया को निष्पादित करें, फिर देखें कि वह बार-बार चल रहा है, जो कि पैटर्न को प्रिंट कर रहा था और फिर इसे जांच रहा था कि स्थिति चल रही है या नहीं;

प्रक्रिया की स्थिति को अक्सर देखने के लिए लूप का उपयोग करते समय

किसी प्रक्रिया की चल स्थिति को देखने और प्राप्त करने के लिए pgrep या किसी अन्य कमांड का उपयोग करें।

अगर pgrep का उपयोग अनावश्यक आउटपुट को / dev / null को आवश्यकतानुसार पुनर्निर्देशित करता है

कोड:

 sleep 12& while pgrep sleep &> /dev/null;do echo -en "#";sleep 0.5;done 

यह "#" नींद समाप्त होने तक मुद्रित होगा, इस पद्धति का उपयोग प्रोग्राम की प्रगति अवधि के लिए प्रगति बार को लागू करने के लिए किया जाता है।

आप इस पद्धति का उपयोग शेल स्क्रिप्टों के आदेशों में भी कर सकते हैं, क्योंकि यह विज़न के रूप में प्रक्रिया के समय का विश्लेषण करता है।

बग: यह pgrep विधि सभी परिस्थितियों में काम नहीं करती, अनपेक्षित रूप से दूसरी प्रक्रिया एक ही नाम के साथ चल रही थी, जबकि लूप समाप्त नहीं होता।

इसलिए प्रक्रिया चलाना स्थिति को पीआईडी ​​निर्दिष्ट करके इसे प्राप्त कर सकते हैं, प्रक्रिया का उपयोग कुछ आदेशों के साथ उपलब्ध हो सकता है,

कमांड पीएस एक आईडी के साथ सभी प्रक्रिया की सूची होगी, आपको निर्दिष्ट प्रक्रिया के pid को खोजने के लिए grep की आवश्यकता है

मैं पिछली बार से लाइनों की एक लक्षित संख्या के खिलाफ एक आदेश आउटपुट की संख्या के आधार पर प्रगति को ट्रैक करना चाहता था:

 #!/bin/bash function lines { local file=$1 local default=$2 if [[ -f $file ]]; then wc -l $file | awk '{print $1}'; else echo $default fi } function bar { local items=$1 local total=$2 local size=$3 percent=$(($items*$size/$total % $size)) left=$(($size-$percent)) chars=$(local s=$(printf "%${percent}s"); echo "${s// /=}") echo -ne "[$chars>"; printf "%${left}s" echo -ne ']\r' } function clearbar { local size=$1 printf " %${size}s " echo -ne "\r" } function progress { local pid=$1 local total=$2 local file=$3 bar 0 100 50 while [[ "$(ps a | awk '{print $1}' | grep $pid)" ]]; do bar $(lines $file 0) $total 50 sleep 1 done clearbar 50 wait $pid return $? } 

फिर इसे इस तरह प्रयोग करें:

 target=$(lines build.log 1000) (mvn clean install > build.log 2>&1) & progress $! $target build.log 

यह एक ऐसा प्रगति पट्टी दिखाता है जो इस तरह दिखता है:

 [===============================================> ] 

बार बढ़ता है क्योंकि लाइन आउटपुट की संख्या लक्ष्य तक पहुंचती है यदि लाइनों की संख्या लक्ष्य से अधिक है, तो बार शुरू होता है (उम्मीद है कि लक्ष्य अच्छा है)।

बीटीडब्ल्यू: मै मैक ओएसएक्स पर बैश का उपयोग कर रहा हूं। मैंने इस कोड को मारियासियो से स्पिनर पर आधारित किया था

 #!/bin/bash function progress_bar() { bar="" total=10 [[ -z $1 ]] && input=0 || input=${1} x="##" for i in `seq 1 10`; do if [ $i -le $input ] ;then bar=$bar$x else bar="$bar " fi done #pct=$((200*$input/$total % 2 + 100*$input/$total)) pct=$(($input*10)) echo -ne "Progress : [ ${bar} ] (${pct}%) \r" sleep 1 if [ $input -eq 10 ] ;then echo -ne '\n' fi } 

एक ऐसा फ़ंक्शन बना सकता है जो इसे पैमाने पर खींचता है, जिसे सलाखों की संख्या के लिए 1-10 कहते हैं:

 progress_bar 1 echo "doing something ..." progress_bar 2 echo "doing something ..." progress_bar 3 echo "doing something ..." progress_bar 8 echo "doing something ..." progress_bar 10 

यदि आपको अस्थायी प्रगति पट्टी दिखानी पड़ेगी (दिखाएगा कि अग्रिम समय में पता है), तो आप पायथन का उपयोग निम्नानुसार कर सकते हैं:

 #!/bin/python from time import sleep import sys if len(sys.argv) != 3: print "Usage:", sys.argv[0], "<total_time>", "<progressbar_size>" exit() TOTTIME=float(sys.argv[1]) BARSIZE=float(sys.argv[2]) PERCRATE=100.0/TOTTIME BARRATE=BARSIZE/TOTTIME for i in range(int(TOTTIME)+1): sys.stdout.write('\r') s = "[%-"+str(int(BARSIZE))+"s] %d%% " sys.stdout.write(s % ('='*int(BARRATE*i), int(PERCRATE*i))) sys.stdout.flush() SLEEPTIME = 1.0 if i == int(TOTTIME): SLEEPTIME = 0.1 sleep(SLEEPTIME) print "" 

इसके बाद, गिनती करते हुए कि आपने पायथन स्क्रिप्ट को progressbar.py रूप में सहेजा है, निम्न कमांड चला कर अपनी बाश स्क्रिप्ट से प्रगति बार दिखाना संभव है:

 python progressbar.py 10 50 

यह एक प्रगति पट्टी के 50 आकार के आकार और 10 सेकंड के लिए "रनिंग" दिखाएगा।

एक टार प्रगति बार बनाने के लिए

 tar xzvf pippo.tgz |xargs -L 19 |xargs -I@ echo -n "." 

जहां "1 9" टैार में फ़ाइलों की संख्या है, वांछित प्रगति पट्टी की लंबाई विभाजित है। उदाहरण: .टीजीज़ में 140 फ़ाइलें हैं और आपको 76 "।" का एक प्रगति पट्टी दिखाई देगी, आप -एल 2 रख सकते हैं।

आपको और कुछ नहीं चाहिए

एक बार जब मेरे पास एक व्यस्त स्क्रिप्ट भी थी जो किसी भी प्रगति को प्रदर्शित किए बिना घंटों तक व्यस्त थी। इसलिए मैंने एक फ़ंक्शन कार्यान्वित किया है, जिसमें मुख्य रूप से पिछली उत्तर की तकनीकें शामिल हैं:

 #!/bin/bash # Updates the progress bar # Parameters: 1. Percentage value update_progress_bar() { if [ $# -eq 1 ]; then if [[ $1 == [0-9]* ]]; then if [ $1 -ge 0 ]; then if [ $1 -le 100 ]; then local val=$1 local max=100 echo -n "[" for j in $(seq $max); do if [ $j -lt $val ]; then echo -n "=" else if [ $j -eq $max ]; then echo -n "]" else echo -n "." fi fi done echo -ne " "$val"%\r" if [ $val -eq $max ]; then echo "" fi fi fi fi fi } update_progress_bar 0 # Further (time intensive) actions and progress bar updates update_progress_bar 100