दिलचस्प बैश प्रोग्रामिंग तकनीक

इन चालों को Google की आंतरिक परियोजना "टॉयलेट पर परीक्षण" (शौचालय में परीक्षण - शौचालयों में पत्रक वितरित करने के लिए परीक्षण के डेवलपर्स को याद दिलाने के लिए) में वर्णित किया गया था।

इस लेख में, उन्हें संशोधित और पूरक किया गया है।

सुरक्षा

मैं प्रत्येक स्क्रिप्ट को निम्नलिखित पंक्तियों के साथ शुरू करता हूं

#!/bin/bash set -o nounset set -o errexit
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यह दो सामान्य गलतियों से बचाता है।

1) अघोषित चर का उपयोग करने का प्रयास

2) आदेशों की असामान्य समाप्ति को अनदेखा करना

यदि आदेश विफल हो सकता है, और यह हमें सूट करता है, तो आप निम्न कोड का उपयोग कर सकते हैं:

 if ! <possible failing command> ; then echo "failure ignored" fi
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यह याद रखना चाहिए कि कुछ कमांड क्रैश कोड जैसे "mkdir -p" और "rm -f" वापस नहीं करते हैं।

एक स्क्रिप्ट से उपप्रोग्राम (कमांड 1 | कमांड 2 | कमांड 3) की कॉलिंग चेन के साथ कठिनाइयां भी हैं, इस प्रतिबंध को दरकिनार करने के लिए, आप निम्नलिखित निर्माण का उपयोग कर सकते हैं:

 (./failing_command && echo A)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इस मामले में, ऑपरेटर '&&' अगली कमांड को निष्पादित नहीं होने देगा, अधिक जानकारी के लिए 'http://fvue.nl/wiki/Bash:_Error_handling' देखें

कार्यों

बैश आपको नियमित कमांड जैसे कार्यों का उपयोग करने की अनुमति देता है, इससे आपके कोड की पठनीयता में सुधार होता है:

उदाहरण 1:

 ExtractBashComments() { egrep "^#" } cat myscript.sh | ExtractBashComments | wc
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

 comments=$(ExtractBashComments < myscript.sh)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

उदाहरण 2:

 SumLines() { # iterating over stdin - similar to awk local sum=0 local line=”” while read line ; do sum=$((${sum} + ${line})) done echo ${sum} } SumLines < data_one_number_per_line.txt
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

उदाहरण 3:

 log() { # classic logger local prefix="[$(date +%Y/%m/%d\ %H:%M:%S)]: " echo "${prefix} $@" >&2 } log "INFO" "a message"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अपने सभी कोड को फ़ंक्शन में स्थानांतरित करने का प्रयास करें, केवल वैश्विक चर / स्थिरांक छोड़कर "मुख्य" फ़ंक्शन को कॉल करना जिसमें सभी उच्च-स्तरीय तर्क होंगे।

परिवर्तनीय घोषणा

बैश आपको कई प्रकार के चर घोषित करने की अनुमति देता है, सबसे महत्वपूर्ण:

स्थानीय (केवल कार्यों के अंदर उपयोग किए जाने वाले चर)

आसानी से (चर जो एक त्रुटि का कारण बनता है उसे पुन: सौंपने का प्रयास करता है)

 ##  DEFAULT_VAL  ,    ,   '-7' readonly DEFAULT_VAL=${DEFAULT_VAL:-7} myfunc() { #       local some_var=${DEFAULT_VAL} ... }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

पहले से घोषित एक से आसानी से टाइप का एक चर बनाना संभव है:

 x=5 x=6 readonly x x=7 # failure
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यह सुनिश्चित करने का प्रयास करें कि आपके सभी चर या तो स्थानीय हैं या आसानी से, यह पठनीयता में सुधार करेगा और त्रुटियों की संख्या को कम करेगा।

बैकटिक्स `` के बजाय $ () का उपयोग करें

बैक कोट्स को पढ़ना मुश्किल है और कुछ फोंट में आसानी से सिंगल कोट्स के साथ भ्रमित किया जा सकता है।

$ () निर्माण भी आपको भागने के साथ सिरदर्द के बिना नेस्टेड कॉल का उपयोग करने की अनुमति देता है:

 #   : ABCD echo "A-`echo B-\`echo C-\\\`echo D\\\`\``" echo "A-$(echo B-$(echo C-$(echo D)))"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

सिंगल ब्रैकेट [] के बजाय डबल स्क्वायर ब्रैकेट [[]] का उपयोग करें

डबल वर्ग कोष्ठक चरों के बजाय अनजाने रास्तों का उपयोग रोकते हैं:

  $ [ a < b ] -bash: b: No such file or directory $ [[ a < b ]]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

कुछ मामलों में, वाक्य रचना सरल है:

 [ "${name}" \> "a" -o ${name} \< "m" ] [[ "${name}" > "a" && "${name}" < "m" ]]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

और अतिरिक्त कार्यक्षमता भी प्रदान करते हैं:



नए ऑपरेटर:

• || तार्किक OR - केवल डबल कोष्ठक के साथ।
• && तार्किक और केवल डबल कोष्ठक के साथ।
• < स्ट्रिंग चर की तुलना (स्ट्रिंग तुलना) - डबल ब्रैकेट के साथ परिरक्षण आवश्यक नहीं है।
• == प्रतिस्थापन के साथ स्ट्रिंग चर की तुलना (स्ट्रिंग ग्लोबिंग के साथ मिलान) - केवल डबल ब्रैकेट के साथ।
• = ~ रेगुलर एक्सप्रेशंस (नियमित एक्सप्रेशंस के साथ मैचिंग स्ट्रिंग) का उपयोग करके स्ट्रिंग वेरिएबल्स की तुलना - केवल डबल ब्रैकेट के साथ।

अनुपूरक / संशोधित परिचालक:

• -संख्यात्मक संख्यात्मक तुलना
• -एन स्ट्रिंग स्ट्रिंग नॉन-खाली
• -z स्ट्रिंग चर खाली है (स्ट्रिंग खाली है)
• -ईक् संख्या संख्यात्मक समानता
• -एक डिजिटल असमानता

उदाहरण:

 t="abc123" [[ "$t" == abc* ]] # true (globbing) [[ "$t" == "abc*" ]] # false (literal matching) [[ "$t" =~ [abc]+[123]+ ]] # true (regular expression) [[ "$t" =~ "abc*" ]] # false (literal matching)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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

 r="a b+" [[ "a bbb" =~ $r ]] # true
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

प्रतिस्थापन वाले स्ट्रिंग चर की तुलना केस स्टेटमेंट में भी उपलब्ध है:

 case $t in abc*) <action> ;; esac
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

स्ट्रिंग चर के साथ काम करें:

बैश में स्ट्रिंग चर के साथ काम करने के कई (कम) विकल्प हैं:

आधार:

 f="path1/path2/file.ext" len="${#f}" # = 20 (  ) #    : ${<>:<_>}  ${<>:<_>:<_>} slice1="${f:6}" # = "path2/file.ext" slice2="${f:6:5}" # = "path2" slice3="${f: -8}" # = "file.ext" (      '-') pos=6 len=5 slice4="${f:${pos}:${len}}" # = "path2"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

प्रतिस्थापन प्रतिस्थापन:

 f="path1/path2/file.ext" single_subst="${f/path?/x}" # = "x/path2/file.ext" (  ) global_subst="${f//path?/x}" # = "x/x/file.ext" (  )
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

चर का पृथक्करण:

 f="path1/path2/file.ext" readonly DIR_SEP="/" array=(${f//${DIR_SEP}/ }) second_dir="${array[1]}" # = path2
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

प्रतिस्थापन हटाने:

# पहले मैच तक लाइन की शुरुआत से हटाएं

 f="path1/path2/file.ext" extension="${f#*.}" # = "ext"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

# आखिरी मैच तक लाइन की शुरुआत से हटाएं

 f="path1/path2/file.ext" filename="${f##*/}" # = "file.ext"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

# पहले मैच के लिए लाइन के अंत से हटाएं

 f="path1/path2/file.ext" dirname="${f%/*}" # = "path1/path2"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

# लाइन से अंतिम मैच तक हटाएं

 f="path1/path2/file.ext" root="${f%%/*}" # = "path1"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अस्थायी फ़ाइलों से छुटकारा पाएं

कुछ कमांड्स एक फ़ाइल नाम की उम्मीद करते हैं, '<()' ऑपरेटर उनकी मदद करेगा, यह एक कमांड को इनपुट में ले जाता है और इसे किसी ऐसी चीज़ में परिवर्तित करता है, जिसका उपयोग फ़ाइल नाम के रूप में किया जा सकता है:

# दो URL डाउनलोड करें और उन्हें अलग करने के लिए पास करें

 diff <(wget -O - url1) <(wget -O - url2)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

मल्टी-लाइन चर को पास करने के लिए टोकन का उपयोग करना:

# मार्कर - कोई भी शब्द।

 command << MARKER ... ${var} $(cmd) ... MARKER
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यदि आप प्रतिस्थापन से बचना चाहते हैं, तो आप मार्कर को उद्धरण चिह्नों में रख सकते हैं:

# कंस्ट्रक्शन '$ var' लौटाएगा न कि वैरिएबल की वैल्यू

 var="text" cat << 'MARKER' ... $var ... MARKER
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

निर्मित चर

• $ 0 स्क्रिप्ट का नाम
• $ 1 $ 2 ... $ n पैरामीटर स्क्रिप्ट / फ़ंक्शन (स्क्रिप्ट / फ़ंक्शन के लिए स्थिती मानदंड) के पास गया
• $ $ स्क्रिप्ट का पीआईडी ​​(स्क्रिप्ट का पीआईडी)
• $! निष्पादित अंतिम कमांड की पीआईडी ​​(और पृष्ठभूमि में चलाएं)
• $? अंतिम कमांड द्वारा स्थिति वापस आ गई (अंतिम कमांड का निकास स्थिति (पाइपलाइड कमांड के लिए $ {PIPESTATUS}))
• $ # स्क्रिप्ट / फ़ंक्शन को दिए गए मापदंडों की संख्या (स्क्रिप्ट / फ़ंक्शन के मापदंडों की संख्या)
• $ @ स्क्रिप्ट / फ़ंक्शन को शब्दों के रूप में प्रस्तुत किए गए सभी पैरामीटर (अलग शब्द के रूप में तर्क देखें)
• $ * स्क्रिप्ट / फ़ंक्शन को दिए गए सभी पैरामीटर, एक शब्द के रूप में प्रस्तुत किए जाते हैं (एकल शब्द के रूप में तर्क देखें)
• एक नियम के रूप में:
• $ * शायद ही उपयोगी है
• $ @ रिक्त स्थान के साथ रिक्त मापदंडों और मापदंडों को सही ढंग से संभालता है
• $ @ जब उपयोग किया जाता है, आमतौर पर दोहरे उद्धरणों में संलग्न होता है - "$ @"

एक उदाहरण:

 for i in "$@"; do echo '$@ param:' $i; done for i in "$*"; do echo '$! param:' $i; done
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

निष्कर्ष:

 bash ./parameters.sh arg1 arg2 $@ param: arg1 $@ param: arg2 $! param: arg1 arg2
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

डिबगिंग

सिंटैक्स जाँच (स्क्रिप्ट 15 सेकंड से अधिक समय चलने पर समय बचाता है):

 bash -n myscript.sh
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अनुरेखण:

 bash -v myscripts.sh
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

जटिल आदेशों के प्रकटीकरण के साथ अनुरेखण:

 bash -x myscript.sh
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

-V और -x पैरामीटर को कोड में सेट किया जा सकता है, यह उपयोगी हो सकता है यदि आपकी स्क्रिप्ट एक मशीन पर चलती है और लॉगिंग निम्न पर है:

 set -o verbose set -o xtrace
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

संकेत हैं कि आपको शेल स्क्रिप्ट का उपयोग नहीं करना चाहिए:

• आपकी स्क्रिप्ट में कुछ सौ से अधिक लाइनें हैं।
• आपको नियमित सरणियों की तुलना में अधिक जटिल डेटा संरचनाओं की आवश्यकता है।
• आप उद्धरण और भागने के साथ अश्लील करने से बीमार हैं।
• आपको कई स्ट्रिंग चर को संसाधित / संशोधित करने की आवश्यकता है।
• आपको तृतीय-पक्ष कार्यक्रमों को कॉल करने की आवश्यकता नहीं है और पाइप की कोई आवश्यकता नहीं है।
• गति / प्रदर्शन आपके लिए महत्वपूर्ण है।

यदि आपका प्रोजेक्ट इस सूची के आइटम से मेल खाता है, तो इसके लिए पायथन या रूबी भाषाओं पर विचार करें।

संदर्भ:

उन्नत बैश-स्क्रिप्टिंग गाइड: tldp.org/LDP/abs/html

बैश संदर्भ मैनुअल: www.gnu.org/software/bash/manual/bashref.html

मूल लेख: robertmuth.blogspot.ru/2012/08/better-bash-scripting-in-15-miner.html