पानी का छींटा या कुछ अन्य खोल "तेज" है?


57

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

लेकिन मैं कुछ शोध किया है, और कुछ लोगों को अपने सभी आशा वे तेजी से चल पाएंगे में पानी का छींटा लिपियों पलायन पाया, और मैं भी लेख में इस पाया DashAsBinSh उबंटू विकी में:

डिफ़ॉल्ट शेल को स्विच करने का प्रमुख कारण दक्षता थी । बैश इंटरैक्टिव उपयोग के लिए उपयुक्त एक उत्कृष्ट पूर्ण विशेषताओं वाला खोल है; वास्तव में, यह अभी भी डिफ़ॉल्ट लॉगिन शेल है। हालांकि, यह डैश के साथ तुलना करके शुरू करने और संचालित करने के लिए बड़ा और धीमा है

आजकल मैं अपने सिस्टम पर कई चीजों के लिए बहुत सारी बैश स्क्रिप्ट का उपयोग कर रहा हूं, और मेरी समस्या यह है कि मेरे पास एक विशेष स्क्रिप्ट है जो मैं लगातार 24/7 चला रहा हूं, जो लगभग 200 बच्चों को जन्म देती है, जो एक साथ मेरे कंप्यूटर को 10 ° तक गर्म करते हैं C सामान्य उपयोग से अधिक।

यह बहुत सारे बशीशों के साथ एक बड़ी स्क्रिप्ट है, इसलिए उन्हें POSIX या किसी अन्य शेल में पोर्ट करने में बहुत समय लगता है (और POSIX वास्तव में व्यक्तिगत उपयोग के लिए मायने नहीं रखता है), लेकिन यह लायक होगा यदि मैं इसमें से कुछ को कम कर सकता हूं सि पि यु का उपयोग। मुझे पता है कि अन्य चीजों पर भी विचार करना होगा, जैसे कि एक बाहरी बाइनरी को कॉल करना, जैसे sedकि साधारण बशीवाद के लिए ${foo/bar}, या grepइसके बजाय =~

टीएल; डीआर वास्तव में डैश के साथ तुलना में शुरू करने और संचालित करने के लिए धीमी है ? क्या अन्य यूनिक्स गोले हैं जो बैश की तुलना में अधिक कुशल हैं ?


12
यदि आप इसे प्रदर्शन के लिए पोर्ट करने जा रहे हैं, तो क्या आपको लगता है कि यह पूरी तरह से किसी अन्य भाषा (पर्ल, पाइथन, रूबी) में बेहतर होगा? वे आम तौर पर बहुत अधिक कुशल होते हैं, मुझे लगता है, हालांकि यह कार्य की सटीक प्रकृति पर निर्भर करेगा।
गोल्डीलॉक्स

मामूली बिंदु: [एक बिलिन भी होना चाहिए।
मिकेल

2
ध्यान रखें कि जब आप मेमोरी उपयोग के बारे में चिंतित होते हैं तो अंतर यह दर्शाता है कि आप बाहरी कार्यक्रमों की बजाय शेल में कंपीटेशन कर रहे हैं (यानी, आप शेल का गलत तरीके से उपयोग कर रहे हैं!)। मेरे कंप्यूटर पर उदाहरण के लिए एक लूप का उपयोग करते हुए एक लाख तक गिनती करने के लिए (और कुछ नहीं करने के लिए) ~ 2x तेजी से mksh / zsh और> 2x तेजी से डैश में है, लेकिन एक वास्तविक स्क्रिप्ट में मैं जितना संभव हो उतना अन्य को लोड करूँगा कार्यक्रम।
लोरब

3
bashबहुत धीमा हुआ करता था। इसने हाल ही में बहुत प्रगति की है, लेकिन ज्यादातर चीजों के लिए, यह अभी भी अन्य गोले की तुलना में धीमी है।
स्टीफन चेज़लस

1
सरल बैशिज़्म का उपयोग न करें । [ "$foo" != "${foo#*bar}" ]अपनी grep चीज़ को संभालता है। और sedबात while [ "$foo" != "${foo#*bar}" ]; do s=$s${foo%%bar*} foo=${foo#*bar} ; done ; foo=$s$foo:। आप या तो किसी फ़ंक्शन में रख सकते हैं।
mikeserv

जवाबों:


39

शेल SEQ:

संभवतः शेल के प्रदर्शन को चिह्नित करने वाले बेंच-मार्क का एक उपयोगी साधन बहुत छोटे, सरल मूल्यांकनों का दोहराव करना है। यह महत्वपूर्ण है, मुझे लगता है, न केवल लूप पर, बल्कि इनपुट पर लूप करने के लिए , क्योंकि एक शेल को पढ़ने की जरूरत है <&0

मैंने सोचा कि यह पहले से ही पोस्ट किए गए परीक्षणों के पूरक होगा @ क्योंकि यह एक बार शेल प्रक्रिया के प्रदर्शन का प्रदर्शन करता है, एक बार आह्वान किए जाने के विपरीत, जो यह दर्शाता है कि आह्वान किए जाने पर शेल प्रक्रिया लोड कितनी जल्दी होती है। इस तरह, हमारे बीच, हम सिक्के के दोनों किनारों को कवर करते हैं।

यहाँ डेमो की सुविधा के लिए एक समारोह है:

sh_bench() (                                               #dont copy+paste comments
    o=-c sh=$(command -v "$1") ; shift                     #get shell $PATH; toss $1
    [ -z "${sh##*busybox}" ] && o='ash -c'                 #cause its weird
    set -- "$sh" $o "'$(cat <&3)'" -- "$@"                 #$@ = invoke $shell
    time env - "$sh" $o "while echo; do echo; done|$*"     #time (env - sh|sh) AC/DC
) 3<<-\SCRIPT                                                                      
#Everything from here down is run by the different shells    
    i="${2:-1}" l="${1:-100}" d="${3:-                     
}"; set -- "\$((n=\$n\${n:++\$i}))\$d"                     #prep loop; prep eval
    set -- $1$1$1$1$1$1$1$1$1$1                            #yup
    while read m                                           #iterate on input
    do  [ $(($i*50+${n:=-$i})) -gt "$(($l-$i))" ] ||       #eval ok?
            eval echo -n \""$1$1$1$1$1"\"                  #yay!
        [ $((n=$i+$n)) -gt "$(($l-$i))" ] &&               #end game?
            echo "$n" && exit                              #and EXIT
        echo -n "$n$d"                                     #damn - maybe next time
    done                                                   #done 
#END
SCRIPT                                                     #end heredoc

यह या तो न्यूलाइन पढ़े जाने के बाद या थोड़ी-अनुकूलन के रूप में एक वेरिएबल को बढ़ाता है, यदि यह हो सकता है, तो यह प्रति बार पढ़ी गई नई लाइन के अनुसार 50 गुना बढ़ाता है। हर बार चर बढ़ने पर इसे मुद्रित किया जाता है stdout। यह एक तरह के seqक्रॉस की तरह व्यवहार करता है nl

और बस यह स्पष्ट करने के लिए कि यह क्या करता है - यहां ऊपर दिए गए फ़ंक्शन में कुछ set -x;सम्मिलित करने के बाद यहां कुछ छोटा आउटपुट दिया timeगया है:

time env - /usr/bin/busybox ash -c '
     while echo; do echo; done |
     /usr/bin/busybox ash -c '"'$(
         cat <&3
     )'"' -- 20 5 busybox'

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

 env - $shell -c "while echo; do echo; done |..."

... उस इनपुट को जेनरेट करने के लिए जब उसमें 3<<\SCRIPT- या जब catभी पढ़ता है, तब उसे लूप करना होगा । और इसके दूसरी तरफ |pipeयह खुद को फिर से कॉल करता है जैसे:

"...| $shell -c '$(cat <<\SCRIPT)' -- $args"

इसलिए प्रारंभिक कॉल से अलग env (क्योंकि catवास्तव में पिछली पंक्ति में कहा जाता है) ; जब तक इसे बाहर नहीं निकाला जाता है, तब तक किसी अन्य प्रक्रिया को लागू नहीं किया जाता है। कम से कम, मुझे आशा है कि यह सच है।

संख्याओं से पहले ...

मुझे पोर्टेबिलिटी पर कुछ नोट्स बनाने चाहिए।

  • poshपसंद नहीं करता है $((n=n+1))और जोर देता है$((n=$n+1))

  • mkshprintfज्यादातर मामलों में एक अंतर्निहित नहीं है । पहले के परीक्षणों में यह काफी हद तक पिछड़ गया था - यह /usr/bin/printfहर रन के लिए आह्वान कर रहा था । इसलिए echo -nऊपर।

  • शायद और अधिक के रूप में मैं इसे याद ...

वैसे भी, संख्या के लिए:

for sh in dash busybox posh ksh mksh zsh bash
do  sh_bench $sh 20 5 $sh 2>/dev/null
    sh_bench $sh 500000 | wc -l
echo ; done

यह सब उन्हें एक बार में मिलेगा ...

0dash5dash10dash15dash20

real    0m0.909s
user    0m0.897s
sys     0m0.070s
500001

0busybox5busybox10busybox15busybox20

real    0m1.809s
user    0m1.787s
sys     0m0.107s
500001

0posh5posh10posh15posh20

real    0m2.010s
user    0m2.060s
sys     0m0.067s
500001

0ksh5ksh10ksh15ksh20

real    0m2.019s
user    0m1.970s
sys     0m0.047s
500001

0mksh5mksh10mksh15mksh20

real    0m2.287s
user    0m2.340s
sys     0m0.073s
500001

0zsh5zsh10zsh15zsh20

real    0m2.648s
user    0m2.223s
sys     0m0.423s
500001

0bash5bash10bash15bash20

real    0m3.966s
user    0m3.907s
sys     0m0.213s
500001

ARBITRARY = MAYBE ठीक है?

फिर भी, यह एक बल्कि मनमाना परीक्षण है, लेकिन यह रीडिंग इनपुट, अंकगणितीय मूल्यांकन और चर विस्तार का परीक्षण करता है। शायद व्यापक नहीं, लेकिन संभवतः वहाँ के निकट।

टेरेसा ई जूनियर द्वारा EDIT : @mikeserv और मैंने कई अन्य परीक्षण किए हैं ( विवरण के लिए हमारी चैट देखें), और हमने पाया कि परिणाम इस तरह संक्षेप में प्रस्तुत किए जा सकते हैं:

  • यदि आपको गति की आवश्यकता है, तो निश्चित रूप से डैश के साथ जाएं , यह किसी भी अन्य शेल की तुलना में बहुत तेज है और बैश की तुलना में लगभग 4 गुना तेज है ।
  • जबकि बिजीबॉक्स के खोल तुलना में बहुत धीमी हो सकता है पानी का छींटा , कुछ परीक्षण में यह तेजी से हो सकता है यह अपने आप ही userland उपयोगिताओं के कई है, क्योंकि, जैसे grep, sed, sort, आदि, जो आमतौर पर इस्तेमाल किया जीएनयू के रूप में कई सुविधाओं की जरूरत नहीं है उपयोगिताओं, लेकिन काम के रूप में ज्यादा मिल सकता है।
  • अगर गति आपकी परवाह करने वाली हर चीज नहीं है, तो ksh (या ksh93 ) को गति और सुविधाओं के बीच सबसे अच्छा समझौता माना जा सकता है। इसकी गति छोटे mksh की तुलना में है , जो बैश की तुलना में तेज़ है , और इसमें कुछ अद्वितीय विशेषताएं भी हैं, जैसे फ़्लोटिंग पॉइंट आर्कटिक
  • हालांकि बैश अपनी सादगी, स्थिरता और कार्यक्षमता के लिए प्रसिद्ध है, यह हमारे परीक्षणों के बहुमत में और बड़े अंतर से सभी गोले में सबसे धीमा था।

मुझे यह कोड बश (और ksh और zsh) में काम करने के लिए नहीं मिल सकता है, केवल डैश, mksh, और pksksh में। बैश I ने 4.2.37(1)-releaseडेबियन से और 4.2.45(2)-releaseएक पोर्टस लाइवसीडी (स्लैकवेयर) से कोशिश की है । बिना null=, आउटपुट संख्याओं के बजाय, यह काम करता है जैसे कि मैंने रिटर्न को लगातार दबाया , फिर मुझे SIGKILL के साथ बैश को मारना होगा
टेरेसा ई जूनियर

और मैंने भी कोशिश की bash --posix, कोई फायदा नहीं हुआ।
टेरेसा ई जूनियर

@TeresaeJunior - शायद यह संभव है - हालांकि मुझे विश्वास नहीं है कि यह साथ काम करेगा zsh। और अच्छी तरह zshसे अपहरण tty, यह एक इंटरैक्टिव खोल का शुभारंभ करेंगे। मुझे उम्मीद bashहै कि मैं ऐसा ही करूंगा - यही कारण है कि मैं केवल इसके --posixलिंक को कॉल करने के लिए सावधान हूं । जैसा कि आप उनमें से अधिकांश के लिए उम्मीद करते हैं, मैं इसे कर सकता हूं, लेकिन यह इसके लायक से अधिक काम हो सकता है। क्या आप फोन bashकर रहे हैं या आप फोन कर रहे हैं sh?
mikeserv

@TeresaeJunior क्या आप यहाँ आकर आउटपुट पोस्ट कर सकते हैं? मैं बस एक बेहतर विचार प्राप्त करना चाहूंगा कि क्या हो रहा है।
mikeserv

क्या मुझे अपने उत्तर के पाठ को आपके नीचे, इसे पूरक करने के लिए नहीं जोड़ना चाहिए, और फिर मेरा हटाना चाहिए?
टेरेसा ई जूनियर

20

एक बेंचमार्क करते हैं।

के साथ bash:

$ strace -cf bash -c 'for i in $(seq 1 1000); do bash -c ":"; done'

% time     seconds  usecs/call     calls    errors syscall
------ ----------- ----------- --------- --------- ----------------
 99.12    0.376044         188      2004      1002 wait4
  0.74    0.002805           3      1002           clone
  0.03    0.000130           0      4037           read
  0.03    0.000119           0     15026           rt_sigprocmask
  0.03    0.000096           0     15040      6017 stat
  0.01    0.000055           0      8011           open
  0.01    0.000024           0      5013           getegid
  0.01    0.000021           0     16027           rt_sigaction
  0.00    0.000017           0      9020      5008 access
  0.00    0.000014           0      1001      1001 getpeername
  0.00    0.000013           0      1001           getpgrp
  0.00    0.000012           0      5013           geteuid
  0.00    0.000011           0     15025           mmap
  0.00    0.000011           0      1002           rt_sigreturn
  0.00    0.000000           0         1           write
  0.00    0.000000           0      8017           close
  0.00    0.000000           0      7011           fstat
  0.00    0.000000           0      8012           mprotect
  0.00    0.000000           0      2004           munmap
  0.00    0.000000           0     18049           brk
  0.00    0.000000           0         1           pipe
  0.00    0.000000           0         1           dup2
  0.00    0.000000           0      1001           getpid
  0.00    0.000000           0      1002           execve
  0.00    0.000000           0      1001           uname
  0.00    0.000000           0      1001           getrlimit
  0.00    0.000000           0      5013           getuid
  0.00    0.000000           0      5013           getgid
  0.00    0.000000           0      1001           getppid
  0.00    0.000000           0      1002           arch_prctl
  0.00    0.000000           0      1001           time
------ ----------- ----------- --------- --------- ----------------
100.00    0.379372                158353     13028 total

के साथ dash:

$ strace -cf bash -c 'for i in $(seq 1 1000); do dash -c ":"; done'
% time     seconds  usecs/call     calls    errors syscall
------ ----------- ----------- --------- --------- ----------------
 73.88    0.008543           4      2004      1002 wait4
 25.35    0.002932           3      1002           clone
  0.62    0.000072           0      9026           rt_sigprocmask
  0.10    0.000011           0      1002           rt_sigreturn
  0.05    0.000006           0     15027           rt_sigaction
  0.00    0.000000           0      1037           read
  0.00    0.000000           0         1           write
  0.00    0.000000           0      2011           open
  0.00    0.000000           0      2017           close
  0.00    0.000000           0      2040        17 stat
  0.00    0.000000           0      2011           fstat
  0.00    0.000000           0      8025           mmap
  0.00    0.000000           0      3012           mprotect
  0.00    0.000000           0      1004           munmap
  0.00    0.000000           0      3049           brk
  0.00    0.000000           0      3020      3008 access
  0.00    0.000000           0         1           pipe
  0.00    0.000000           0         1           dup2
  0.00    0.000000           0      1001           getpid
  0.00    0.000000           0         1         1 getpeername
  0.00    0.000000           0      1002           execve
  0.00    0.000000           0         1           uname
  0.00    0.000000           0         1           getrlimit
  0.00    0.000000           0        13           getuid
  0.00    0.000000           0        13           getgid
  0.00    0.000000           0      1013           geteuid
  0.00    0.000000           0        13           getegid
  0.00    0.000000           0      1001           getppid
  0.00    0.000000           0         1           getpgrp
  0.00    0.000000           0      1002           arch_prctl
  0.00    0.000000           0         1           time
------ ----------- ----------- --------- --------- ----------------
100.00    0.011564                 60353      4028 total

प्रत्येक पुनरावृत्ति केवल एक शेल शुरू करती है और बिना-ऑप संचालक के साथ कुछ भी नहीं करती है - बृहदान्त्र , फिर छोड़ दिया।

परिणाम दिखाने के रूप में, स्टार्टअप की dashतुलना bashमें बहुत तेज है । dashइससे छोटा है, और bashनिम्न साझा लाइब्रेरी पर निर्भर है :

$ du -s /bin/bash 
956 /bin/bash

$ du -s /bin/dash 
108 /bin/dash

$ ldd /bin/bash
    linux-vdso.so.1 =>  (0x00007fffc7947000)
    libtinfo.so.5 => /lib/x86_64-linux-gnu/libtinfo.so.5 (0x00007f5a8110d000)
    libdl.so.2 => /lib/x86_64-linux-gnu/libdl.so.2 (0x00007f5a80f09000)
    libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f5a80b7d000)
    /lib64/ld-linux-x86-64.so.2 (0x00007f5a81352000)

$ ldd /bin/dash
    linux-vdso.so.1 =>  (0x00007fff56e5a000)
    libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007fb24844c000)
    /lib64/ld-linux-x86-64.so.2 (0x00007fb2487f3000)

यह स्टार्टअप समय के बारे में है, कैसे संचालित होता है। एक और बेंचमार्क करते हैं:

$ time dash -c 'for i in $(seq 1 1000000);do [ 1 = 1 ];done'

real    0m2.684s
user    0m2.728s
sys     0m0.100s

$ time bash -c 'for i in $(seq 1 1000000);do [ 1 = 1 ];done'

real    0m6.996s
user    0m6.820s
sys     0m0.376s

सरल परीक्षण के साथ 1 = 1, dashअभी भी बहुत तेजी से bash


आपके उत्तर की बहुत सराहना की जाती है, लेकिन ऐसा लगता है कि आप केवल माप रहे हैं कि स्टार्टअप के लिए शेल कितना तेज़ है, न कि वास्तव में यह कितनी तेज़ी से संचालित होता है, है ना?
टेरेसा ई जूनियर

1
@TeresaeJunior: हां, मैं केवल स्टार्टअप समय के बारे में उल्लेख करता हूं।
cuonglm

मुझे लगता है seq 1 100000होना चाहिए seq 1 1000?
मिकेल

1
लेकिन आपके dashपरीक्षण के मामले के लिए यह केवल है seq 1 1000?
मिकेल

ओह, क्षमा करें, यह 1000स्टार्टअप के लिए है और 1000000संचालित करने के लिए, निश्चित है।
cuonglm

7

यहाँ एक प्रमाणित यूनिक्स (मैक ओएस एक्स 10.10.3) में विभिन्न गोले के कुछ स्टार्टअप समय हैं। मैंने लूप्स को नियंत्रित करने के लिए tcsh का उपयोग करने के लिए परीक्षण को फिर से लिखा है ताकि शेल का परीक्षण किया जा रहा है जो लूप को नियंत्रित करने वाला नहीं था। प्रत्येक शेल के लिए लूप को समय से पहले पांच बार निष्पादित किया जाता है, यह सुनिश्चित करने के लिए कि शेल निष्पादन योग्य है और स्क्रिप्ट कैश में हैं।

जैसा कि आप देख सकते हैं, कोई भी स्पष्ट विजेता नहीं है, लेकिन एक निश्चित हार है। किसी भी तरह, बैश 4 बैश से अलग है। 3. डैश अच्छा प्रदर्शन करता है, लेकिन यह देखते हुए कि ksh93 अब ओपन-सोर्स है, हर चीज के लिए इसका उपयोग न करने का कोई वास्तविक कारण नहीं है (अगर मैं किसी भी लाइसेंसिंग निकेटीस को गलत समझता हूं: ksh93 तेज, ठोस है , और UNIX- भूमि (यदि यह GNU / Linux- भूमि में नहीं है) में एक वास्तविक मानक; यह POSIX शेल कार्यक्षमता का एक सुपरसेट प्रदान करता है (जहां तक ​​मैं समझता हूं, POSIX शेल ksh88 पर आधारित था); यह एक इंटरैक्टिव शेल के रूप में बैश करने के बराबर है, हालांकि tcsh की तुलना में पिछड़ रहा है। और हारने वाला बेशक zsh का हो।

/bin/bash is v3.2.57(1)
/usr/local/bin/bash is v4.3.33(1)
dash is v0.5.8
ksh is v93u+
mksh is vR50f
pdksh is v5.2.14
/opt/heirloom/5bin/sh is from SysV
yash is v2.37
zsh is v5.0.5

% cat driver.csh 
#!/bin/tcsh

foreach s ( $* )
    echo
    echo "$s"
    foreach i ( `seq 1 5` )
        ./simple_loop.csh "$s"
    end
    /usr/bin/time -p ./simple_loop.csh "$s"
end

% cat simple_loop.csh 
#!/bin/tcsh

set shell = `which ${1}`
foreach i ( `seq 1 1000` )
    ${shell} -c ":"
end

% ./driver.csh /bin/bash /usr/local/bin/bash dash ksh mksh pdksh /opt/heirloom/5bin/sh yash zsh 
/bin/bash
real         4.21
user         1.44
sys          1.94

/usr/local/bin/bash
real         5.45
user         1.44
sys          1.98

dash
real         3.28
user         0.85
sys          1.11

ksh
real         3.48
user         1.35
sys          1.68

mksh
real         3.38
user         0.94
sys          1.14

pdksh
real         3.56
user         0.96
sys          1.17

/opt/heirloom/5bin/sh
real         3.46
user         0.92
sys          1.11

yash
real         3.97
user         1.08
sys          1.44

zsh
real        10.88
user         3.02
sys          5.80

मेरा निष्कर्ष ksh93 का भी उपयोग कर रहा था। यह कॉमन पब्लिक लाइसेंस के तहत है, जिसे एफएसएफ द्वारा अनुमोदित किया गया है।
टेरेसा ई जूनियर

0

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

एक अच्छी तुलना है: प्रत्येक शेल में सबसे अच्छा संभव कमांड लाइन का उपयोग करने के लिए, एक विशिष्ट नौकरी खत्म करने के लिए। न केवल बिल्कुल एक ही कमांड लाइन, जब केवल एक शेल वास्तव में यहां एक फायदा है। इस तरह की तुलना अविश्वसनीय है और प्रतियोगियों का वास्तविक प्रदर्शन नहीं दिखाती है। मैं अपनी हर दिन की नौकरी को देखता हूं, जो कई उपयोग मामलों में तेज है।

उदाहरण के लिए, सभी aवर्णों को स्ट्रिंग में वर्णों से बदलने के लिए, bबैश में आप लिख सकते हैं "${varname//a/b}"जबकि डैश में आपको इस तरह से बाहरी टूल को कॉल करना होगा "$(echo "$varname" | sed 's/a/b/g')":। यदि आपको इसे कुछ सौ बार दोहराना है - बैशीवाद का उपयोग करके आप 2x स्पीडअप दे सकते हैं।


3
क्या आपके पास कोई ऐसा उदाहरण है जिससे आप अपने उत्तर को अपडेट कर सकते हैं कि कैसे प्रदर्शन के अंतर को बंद कर सकते हैं या समकक्ष कार्यों पर भी तेज़ हो सकते हैं? आपका उत्तर कुछ विशिष्ट उदाहरणों के साथ बहुत अधिक मजबूत होगा।
एरिक रेनॉफ
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.