🛌🏿 🚴 📠 बैश में स्क्रिप्टिंग तकनीक 🚶🏻 🆒 🍱

लिनक्स प्रशासकों को नियमित रूप से बैश पर स्क्रिप्ट लिखना होता है। नीचे मैं इस काम में तेजी लाने के साथ-साथ स्क्रिप्ट की विश्वसनीयता में सुधार करने के टिप्स देता हूं।

टिप 1

ऐसी स्क्रिप्ट न लिखें जो कुछ भी पूछे बिना कार्रवाई करती हैं। ऐसी लिपियों की शायद ही कभी आवश्यकता होती है। लेकिन किसी भी चीज़ को कॉपी करने, सिंक्रोनाइज़ करने, लॉन्च करने के लिए "अच्छे" के सभी प्रकार, पर्याप्त से अधिक। और अगर आपने अचानक अपने पसंदीदा मिडनाइट कमांडर में गलत स्क्रिप्ट पर क्लिक किया, तो सिस्टम को कुछ भी हो सकता है। यह ट्रैफिक नियमों की तरह है - "खून में लिखा है।"

टिप 2

पिछले एक के आधार पर, प्रत्येक स्क्रिप्ट की शुरुआत में निम्नलिखित की तरह कुछ डालना अच्छा है:

read -n 1 -p " ,     (y/[a]): " AMSURE [ "$AMSURE" = "y" ] || exit echo "" 1>&2

इको कमांड, वैसे, यहां आवश्यक है क्योंकि <y> बटन दबाने के बाद आपके पास एक पंक्ति फ़ीड नहीं होगी, इसलिए, कोई भी अन्य आउटपुट उसी पंक्ति में जाएगा।

टिप 3

यह सभी की प्रमुख टिप है। हर बार एक ही चीज़ न लिखने के लिए, फंक्शन लाइब्रेरीज़ का उपयोग करें। बैश पर कई लेख पढ़ने के बाद, मुझे यह स्वीकार करना होगा कि इस विषय पर थोड़ा ध्यान दिया जाता है। शायद सबूत की वजह से। हालांकि, मैं इसे वापस बुलाना जरूरी समझता हूं। So.
अपने स्वयं के फ़ंक्शन लाइब्रेरी, जैसे कि myfunc.sh, और इसे, उदाहरण के लिए, / usr / bin में रखें। स्क्रिप्ट लिखते समय, यह न केवल आपके काम को कम करने में मदद करेगा, बल्कि यह आपको किसी भी फ़ंक्शन में सुधार करने पर एक गिर गए झपट्टा में कई लिपियों को संशोधित करने की अनुमति देगा।
उदाहरण के लिए, टिप 2 के प्रकाश में, आप इस तरह से एक फ़ंक्शन लिख सकते हैं:

 myAskYN() { local AMSURE if [ -n "$1" ] ; then read -n 1 -p "$1 (y/[a]): " AMSURE else read -n 1 AMSURE fi echo "" 1>&2 if [ "$AMSURE" = "y" ] ; then return 0 else return 1 fi }

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

 myAskYN " ,    ?" || exit

आप एक और समान फ़ंक्शन myAskYNE लिख सकते हैं, अंत में ई अक्षर के साथ, जिसमें वापसी को निकास से बदल दिया जाता है। फिर रिकॉर्ड भी सरल हो जाएगा:

 myAskYNE " ,    ?"

लाभ स्पष्ट हैं: ए) आप कम कोड लिखते हैं, बी) कोड को पढ़ना आसान है, ग) आप ट्राइफल्स से विचलित नहीं होते हैं, जैसे कि उपसर्ग "(y / [a]):" परीक्षण के लिए (I ध्यान दें कि [a] का अर्थ है कोई, और वर्ग में लिया गया एक) उद्धरण चिह्न इंगित करता है कि यह डिफ़ॉल्ट है)।
और यहाँ आखिरी। हमारी लाइब्रेरी से कार्यों का उपयोग करने के लिए, आपको इसे स्क्रिप्ट में ही शामिल करना नहीं भूलना चाहिए:

 #!/bin/bash a1=myfunc.sh ; source "$a1" ; if [ $? -ne 0 ] ; then echo " —    $a1" 1>&2 ; exit 1 ; fi myAskYN " ,    ?" echo Run!

मैंने जानबूझकर पूरी कॉल और त्रुटि हैंडलिंग को एक पंक्ति में रखा है, क्योंकि यह एक मानक चीज है और स्क्रिप्ट तर्क पर सीधे लागू नहीं होती है। इसे आधी स्क्रीन तक क्यों बढ़ाया जाए? यह भी ध्यान दें कि स्क्रिप्ट नाम चर को सौंपा गया है। यह आपको स्क्रिप्ट नाम को एक बार सेट करने की अनुमति देता है, और इसलिए, यदि आवश्यक हो, तो आप स्ट्रिंग को डुप्लिकेट कर सकते हैं और फ़ंक्शन के दूसरे लाइब्रेरी को कनेक्ट करने के लिए लाइब्रेरी का नाम बदल सकते हैं।
अब, इन तीन पंक्तियों के साथ शुरू होने वाली कोई भी स्क्रिप्ट बिना पुष्टि के कभी भी कुछ निष्पादित नहीं करेगी। मैं इसे आप के लिए एक समान फ़ंक्शन लिखने के लिए छोड़ देता हूं myAskYN myAskYESNO बुलाया।

टिप 4

हम सफलता का विकास करेंगे और न्यूनतम टिप्पणियों के साथ कुछ स्पष्ट कार्य प्रदर्शित करेंगे।

 sayWait() { local AMSURE [ -n "$1" ] && echo "$@" 1>&2 read -n 1 -p "(    )" AMSURE echo "" 1>&2 } cdAndCheck() { cd "$1" if ! [ "$(pwd)" = "$1" ] ; then echo "!!     $1 -  . ." 1>&2 exit 1 fi } checkDir() { if ! [ -d "$1" ] ; then if [ -z "$2" ] ; then echo "!!  $1 -  . ." 1>&2 else echo "$2" 1>&2 fi exit 1 fi } checkFile() { if ! [ -f "$1" ] ; then if [ -z "$2" ] ; then echo "!!  $1 -  . ." 1>&2 else echo "$2" 1>&2 fi exit 1 fi } checkParm() { if [ -z "$1" ] ; then echo "!!$2.  . ." 1>&2 exit 1 fi }

यहाँ मैं आपका ध्यान प्रतिध्वनि के बाद लगातार 1> & 2 के संयोजन की ओर आकर्षित करता हूँ। तथ्य यह है कि आपकी स्क्रिप्ट शायद कुछ मूल्यवान जानकारी प्रदर्शित करेगी। और यह जानकारी हमेशा स्क्रीन पर फिट नहीं होगी, और इसलिए इसे फ़ाइल में सहेजना या इसे कम पर भेजना अच्छा हो सकता है। संयोजन 1> और 2 का मतलब आउटपुट को एक मानक त्रुटि डिवाइस पर पुनर्निर्देशित करना है। और जब आप स्क्रिप्ट को इस तरह से लागू करते हैं:

 my-script.sh > out.txt my-script.sh | less

इसमें अनावश्यक गलत और सेवा संदेश नहीं होंगे, लेकिन केवल वही जो आप वास्तव में दिखाना चाहते हैं।

टिप 5

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

 curPath= #     ,    cRes= #        pYes= #  --yes,

अब हम संग्रह में एक और उपयोगी कार्य जोड़ सकते हैं:

 input1() { local a1 if [ -n "$1" ] ; then read -p "$1" -sn 1 cRes else read -sn 1 cRes fi #    while [ "$2" = "${2#*$cRes}" ] ; do read -sn 1 cRes done echo $cRes 1>&2 }

यहाँ इसके उपयोग का एक उदाहरण है:

 cat <<'EOF'   : ------------------------ a)  1 b)  2 .)  EOF input1 " : " "ab." echo " : $cRes"

यह फ़ंक्शन कीस्ट्रोक्स को निर्दिष्ट लोगों की सूची में प्रतिबंधित करता है (उदाहरण के लिए, ए, बी और अवधि)। कोई अन्य कुंजी नहीं होगी और जब दबाया जाएगा, तो कुछ भी आउटपुट नहीं होगा। उदाहरण रिटर्न चर ($ cRes) के उपयोग को भी दर्शाता है। यह उपयोगकर्ता द्वारा दबाया गया पत्र लौटाता है।

टिप 6

मापदंडों के बिना क्या स्क्रिप्ट? उनके प्रसंस्करण के बारे में एक टन साहित्य लिखा गया है। मैं अपनी दृष्टि साझा करूंगा।

यह अत्यधिक वांछनीय है कि मापदंडों को उनके अनुक्रम की परवाह किए बिना संसाधित किया जाए।
मुझे इस सरल कारण के लिए एकल-पत्र मापदंडों (और इसलिए गेटटॉप्स) का उपयोग करना पसंद नहीं है कि बहुत सारी स्क्रिप्ट और कुछ अक्षर हैं। और याद रखें कि एक स्क्रिप्ट के लिए, -r का मतलब है, दूसरे की प्रतिकृति के लिए, और तीसरे के लिए इसे हटाना लगभग असंभव है। इसलिए, मैं 2 नोटेशन का उपयोग करता हूं, और एक ही समय में: a) --show-files-only, b) -sfo (पिछले एक से संक्षिप्त नाम के रूप में)। अभ्यास से पता चलता है कि ऐसी चाबियाँ तुरंत और बहुत लंबे समय के लिए याद की जाती हैं।
स्क्रिप्ट को एक अज्ञात पर एक त्रुटि फेंकनी चाहिए। यह पैरामीटर लिखते समय त्रुटियों की पहचान करने में आंशिक रूप से मदद करेगा।
टिप 2 से हम नियम लेते हैं: बिना पुष्टि के कभी भी स्क्रिप्ट न चलाएं। लेकिन इसे एक महत्वपूर्ण अपवाद में जोड़ें - यदि --yes कुंजी निर्दिष्ट नहीं है (कुंजी, निश्चित रूप से, कोई भी हो सकती है)।
मान का अनुसरण किया जा सकता है। इस स्थिति में, निम्न नियम लंबी कुंजियों के लिए लागू होता है: - स्रोत-फ़ाइल = my.txt (बराबर में वर्तनी), और छोटी कुंजी के लिए: -sf my.txt (अंतरिक्ष में)।

इस प्रकाश में, पैरामीटर प्रसंस्करण इस तरह दिख सकता है:

 while [ 1 ] ; do if [ "$1" = "--yes" ] ; then pYes=1 elif [ "${1#--source-file=}" != "$1" ] ; then pSourceFile="${1#--source-file=}" elif [ "$1" = "-sf" ] ; then shift ; pSourceFile="$1" elif [ "${1#--dest-file=}" != "$1" ] ; then pDestFile="${1#--dest-file=}" elif [ "$1" = "-df" ] ; then shift ; pDestFile="$1" elif [ -z "$1" ] ; then break #   else echo ":  " 1>&2 exit 1 fi shift done checkParm "$pSourceFile" "   " checkParm "$pDestFile" "   " if [ "$pYes" != "1" ] ; then myAskYNE " ,    ?" fi echo "source=$pSourceFile, destination=$pDestFile"

यह कोड निम्नलिखित विशेषताएं प्रदान करता है:

 ./test.sh -sf mysource -df mydest ./test.sh --source-file=mysource --dest-file=mydest ./test.sh --source-file=mysource --dest-file=mydest --yes

पैरामीटर को किसी भी क्रम में और पूर्ण और संक्षिप्त कुंजियों के संयोजन में सेट किया जा सकता है।
चूंकि मापदंडों की आवश्यकता होती है, उनकी उपस्थिति की जांच होती है (लेकिन शुद्धता नहीं), checkParm के लिए धन्यवाद।
यदि - आपकी कुंजी गायब है, तो एक पुष्टिकरण संदेश की आवश्यकता होगी।

यह मूल भाग है, जिसे और विकसित किया जा सकता है। उदाहरण के लिए, हमारे पुस्तकालय में कुछ पैरामीटर प्रोसेसिंग फ़ंक्शंस जोड़ें:

 procParmS() { [ -z "$2" ] && return 1 if [ "$1" = "$2" ] ; then cRes="$3" return 0 fi return 1 } procParmL() { [ -z "$1" ] && return 1 if [ "${2#$1=}" != "$2" ] ; then cRes="${2#$1=}" return 0 fi return 1 }

इस मामले में, पैरामीटर प्रसंस्करण चक्र बहुत अधिक सुपाच्य लगेगा:

 while [ 1 ] ; do if [ "$1" = "--yes" ] ; then pYes=1 elif procParmS "-sf" "$1" "$2" ; then pSourceFile="$cRes" ; shift elif procParmL "--source-file" "$1" ; then pSourceFile="$cRes" elif procParmS "-df" "$1" "$2" ; then pDestFile="$cRes" ; shift elif procParmL "--dest-file" "$1" ; then pDestFile="$cRes" elif [ -z "$1" ] ; then break #   else echo ":  " 1>&2 exit 1 fi shift done

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