अपनी बैश स्क्रिप्ट्स में एक मजबूत हेल्प सिस्टम जोड़ें

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

इस श्रृंखला के चार लेखों में से यह तीसरा लेख बताता है कि एक साधारण हेल्प फ़ंक्शन कैसे बनाया और उपयोग किया जाए। अपना हेल्प सुविधा बनाते समय, आप फ़ंक्शंस का उपयोग करने और -h जैसे कमांड-लाइन ऑप्शंस को कैसे संभालना है, इसके बारे में भी सीखेंगे।

क्यों हेल्प?

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

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

फ़ंक्शंस के बारे में

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

स्क्रिप्ट्स या कमांड-लाइन इंटरफेस (CLI) में उनके नामों का उपयोग करके फ़ंक्शंस को कॉल किया जाता है, जैसे आप किसी अन्य कमांड के लिए करेंगे। एक CLI प्रोग्राम या स्क्रिप्ट में, फ़ंक्शन में कमांड्स तब निष्पादित होती हैं जब उन्हें कॉल किया जाता है, फिर प्रोग्राम फ्लो सीक्वेंस कॉलिंग एंटिटी पर वापस आता है, और उस एंटिटी में कॉलिंग स्टेटमेंट के बाद प्रोग्राम स्टेटमेंट्स की अगली श्रृंखला निष्पादित होती है।

एक फ़ंक्शन का सिंटैक्स है:

FunctionName(){program statements}

कमांड लाइन पर एक सरल फ़ंक्शन बनाकर इसका पता लगाएं। (फ़ंक्शन उस शेल इंस्टेंस के शेल एनवायरनमेंट में स्टोर होता है जिसमें यह बनाया गया है।) आप hw नामक एक फ़ंक्शन बनाने जा रहे हैं, जो "हैलो वर्ल्ड" के लिए खड़ा है। कमांड लाइन पर निम्न कोड दर्ज करें और Enter दबाएं। फिर hw दर्ज करें जैसे आप किसी अन्य शेल कमांड के लिए करेंगे:

[student@testvm1 ~]$ hw(){ echo "Hi there kiddo"; }
 [student@testvm1 ~]$ hw
 Hi there kiddo
 [student@testvm1 ~]$

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

[student@testvm1 ~]$ declare -f | less
 <snip>
 hw () 
 { 
 echo "Hi there kiddo"
 }
 <snip>

उस फ़ंक्शन को हटा दें क्योंकि अब आपको इसकी आवश्यकता नहीं है। आप इसे unset कमांड से कर सकते हैं:

[student@testvm1 ~]$ unset -f hw ; hw
 bash: hw: command not found
 [student@testvm1 ~]$

हेल्प फ़ंक्शन बनाना

hello प्रोग्राम को एक एडिटर में खोलें और नीचे दिए गए हेल्प फ़ंक्शन को hello प्रोग्राम कोड में कॉपीराइट स्टेटमेंट के बाद लेकिन echo "Hello world!" स्टेटमेंट से पहले जोड़ें। यह हेल्प फ़ंक्शन प्रोग्राम का एक संक्षिप्त विवरण, एक सिंटैक्स डायग्राम, और उपलब्ध ऑप्शंस के संक्षिप्त विवरण प्रदर्शित करेगा। इसका परीक्षण करने के लिए हेल्प फ़ंक्शन की एक कॉल और कुछ कमेंट लाइनें जोड़ें जो फ़ंक्शंस और प्रोग्राम के मुख्य भाग के बीच एक दृश्य सीमांकन प्रदान करती हैं:

################################################################################
 # Help #
 ################################################################################
 Help()
 {
 # Display Help
 echo "Add description of the script functions here."
 echo
 echo "Syntax: scriptTemplate [-g|h|v|V]"
 echo "options:"
 echo "g Print the GPL license notification."
 echo "h Print this Help."
 echo "v Verbose mode."
 echo "V Print software version and exit."
 echo
 }
 
 ################################################################################
 ################################################################################
 # Main program #
 ################################################################################
 ################################################################################
 
 Help
 echo "Hello world!"

प्रोग्राम को यह टेस्ट करने के लिए चलाएं:

[student@testvm1 ~]$ ./hello
 Add description of the script functions here.
 
 Syntax: scriptTemplate [-g|h|v|V]
 options:
 g Print the GPL license notification.
 h Print this Help.
 v Verbose mode.
 V Print software version and exit.
 
 Hello world!
 [student@testvm1 ~]$

क्योंकि आपने हेल्प को केवल तभी प्रदर्शित करने के लिए कोई लॉजिक नहीं जोड़ा है जब आपको इसकी आवश्यकता हो, प्रोग्राम हमेशा हेल्प प्रदर्शित करेगा। चूंकि फ़ंक्शन सही ढंग से काम कर रहा है, कमांड लाइन पर प्रोग्राम को लागू करते समय -h ऑप्शन का उपयोग किए जाने पर ही हेल्प प्रदर्शित करने के लिए कुछ लॉजिक जोड़ने के लिए आगे पढ़ें।

ऑप्शंस को संभालना

बैश स्क्रिप्ट की -h जैसे कमांड-लाइन ऑप्शंस को संभालने की क्षमता प्रोग्राम को निर्देशित करने और यह संशोधित करने के लिए कुछ शक्तिशाली क्षमताएं देती है कि यह क्या करता है। -h ऑप्शन के मामले में, आप चाहते हैं कि प्रोग्राम हेल्प टेक्स्ट को टर्मिनल सेशन पर प्रिंट करे और फिर शेष प्रोग्राम को चलाए बिना बाहर निकल जाए। कमांड लाइन पर दर्ज ऑप्शंस को प्रोसेस करने की क्षमता को while कमांड (अधिक जानने के लिए बैश के साथ प्रोग्राम कैसे करें: लूप्स देखें) का उपयोग करके getops और case कमांड्स के साथ संयोजन में बैश स्क्रिप्ट में जोड़ा जा सकता है।

getops कमांड कमांड लाइन पर निर्दिष्ट किसी भी और सभी ऑप्शंस को पढ़ता है और उन ऑप्शंस की एक सूची बनाता है। नीचे दिए गए कोड में, while कमांड वेरिएबल $options को प्रत्येक के लिए सेट करके ऑप्शंस की सूची के माध्यम से लूप करता है। case स्टेटमेंट का उपयोग प्रत्येक ऑप्शन को क्रम में मूल्यांकन करने और संबंधित स्टैंजा में स्टेटमेंट्स को निष्पादित करने के लिए किया जाता है। while स्टेटमेंट ऑप्शंस की सूची का मूल्यांकन तब तक जारी रखेगा जब तक उन सभी को प्रोसेस नहीं किया जाता या यह एक एग्जिट स्टेटमेंट का सामना नहीं करता, जो प्रोग्राम को समाप्त करता है।

echo "Hello world!" स्टेटमेंट से ठीक पहले हेल्प फ़ंक्शन कॉल को हटाना सुनिश्चित करें ताकि प्रोग्राम का मुख्य भाग अब इस तरह दिखे:

################################################################################
 ################################################################################
 # Main program #
 ################################################################################
 ################################################################################
 ################################################################################
 # Process the input options. Add options as needed. #
 ################################################################################
 # Get the options
 while getopts ":h" option; do
 case $option in
 h) # display Help
 Help
 exit;;
 esac
 done
 
 echo "Hello world!"

case ऑप्शन में एग्जिट स्टेटमेंट के अंत में डबल सेमीकोलन पर ध्यान दें। यह इस case स्टेटमेंट में जोड़े गए प्रत्येक ऑप्शन के लिए प्रत्येक ऑप्शन के अंत को सीमांकित करने के लिए आवश्यक है।

टेस्टिंग

टेस्टिंग अब थोड़ी अधिक जटिल है। आपको अपने प्रोग्राम को कई अलग-अलग ऑप्शन्स के साथ—और बिना ऑप्शन्स के—टेस्ट करने की आवश्यकता है यह देखने के लिए कि यह कैसे प्रतिक्रिया करता है। पहले, बिना ऑप्शन्स के टेस्ट करें ताकि यह सुनिश्चित हो सके कि यह "Hello world!" प्रिंट करता है जैसा इसे करना चाहिए:

[student@testvm1 ~]$ ./hello
 Hello world!

यह काम करता है, तो अब हेल्प टेक्स्ट प्रदर्शित करने वाले लॉजिक का टेस्ट करें:

[student@testvm1 ~]$ ./hello -h
 Add description of the script functions here.
 
 Syntax: scriptTemplate [-g|h|t|v|V]
 options:
 g Print the GPL license notification.
 h Print this Help.
 v Verbose mode.
 V Print software version and exit.

यह अपेक्षा के अनुरूप काम करता है, तो कुछ टेस्टिंग आज़माएं यह देखने के लिए कि क्या होता है जब आप कुछ अप्रत्याशित ऑप्शंस दर्ज करते हैं:

[student@testvm1 ~]$ ./hello -x
 Hello world!
 [student@testvm1 ~]$ ./hello -q
 Hello world!
 [student@testvm1 ~]$ ./hello -lkjsahdf
 Add description of the script functions here.
 
 Syntax: scriptTemplate [-g|h|t|v|V]
 options:
 g Print the GPL license notification.
 h Print this Help.
 v Verbose mode.
 V Print software version and exit.
 
 [student@testvm1 ~]$

प्रोग्राम विशिष्ट प्रतिक्रियाओं के बिना किसी भी ऑप्शन को बिना किसी त्रुटि के उत्पन्न किए अनदेखा करता है। लेकिन अंतिम प्रविष्टि ( -lkjsahdf ऑप्शन के साथ) पर ध्यान दें: क्योंकि ऑप्शन की सूची में एक h है, प्रोग्राम इसे पहचानता है और हेल्प टेक्स्ट प्रिंट करता है। इस टेस्टिंग ने दिखाया है कि प्रोग्राम में गलत इनपुट को संभालने और यदि कोई पाया जाता है तो प्रोग्राम को समाप्त करने की क्षमता नहीं है।

आप case स्टेटमेंट में एक और case स्टैंजा जोड़ सकते हैं जो किसी भी ऑप्शन से मेल खाता है जिसका कोई स्पष्ट मेल नहीं है। यह सामान्य case उन सभी चीज़ों से मेल खाएगा जिनके लिए आपने विशिष्ट मेल प्रदान नहीं किया है। case स्टेटमेंट अब इस तरह दिखता है, जिसमें कैच-ऑल मैच \? अंतिम case के रूप में है। किसी भी अतिरिक्त विशिष्ट case को इस अंतिम से पहले होना चाहिए:

while getopts ":h" option; do
 case $option in
 h) # display Help
 Help
 exit;;
 \?) # incorrect option
 echo "Error: Invalid option"
 exit;;
 esac
 done

प्रोग्राम को पहले की तरह ही ऑप्शन्स का उपयोग करके फिर से टेस्ट करें और देखें कि यह अब कैसे काम करता है।

आप कहां हैं

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

#!/usr/bin/bash
 ################################################################################
 # scriptTemplate #
 # #
 # Use this template as the beginning of a new program. Place a short #
 # description of the script here. #
 # #
 # Change History #
 # 11/11/2019 David Both Original code. This is a template for creating #
 # new Bash shell scripts. #
 # Add new history entries as needed. #
 # #
 # #
 ################################################################################
 ################################################################################
 ################################################################################
 
 ################################################################################
 # Help #
 ################################################################################
 Help()
 {
 # Display Help
 echo "Add description of the script functions here."
 echo
 echo "Syntax: scriptTemplate [-g|h|t|v|V]"
 echo "options:"
 echo "g Print the GPL license notification."
 echo "h Print this Help."
 echo "v Verbose mode."
 echo "V Print software version and exit."
 echo
 }
 
 ################################################################################
 ################################################################################
 # Main program #
 ################################################################################
 ################################################################################
 ################################################################################
 # Process the input options. Add options as needed. #
 ################################################################################
 # Get the options
 while getopts ":h" option; do
 case $option in
 h) # display Help
 Help
 exit;;
 \?) # incorrect option
 echo "Error: Invalid option"
 exit;;
 esac
 done
 
 echo "Hello world!"

इस संस्करण का प्रोग्राम बहुत अच्छी तरह से टेस्ट करना सुनिश्चित करें। रैंडम इनपुट्स का उपयोग करें और देखें क्या होता है। आपको वैध और अवैध ऑप्शन्स को डैश (-) के बिना सामने टेस्ट करने का भी प्रयास करना चाहिए।

अगली बार

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

अगला लेख वेरिएबल्स को इनिशियलाइज़ करने और यह सुनिश्चित करने के लिए थोड़ी सी सनिटी चेकिंग करने पर ध्यान देगा कि प्रोग्राम सही परिस्थितियों में चलेगा।

संसाधन

• बैश के साथ प्रोग्राम कैसे करें: सिंटैक्स और टूल्स
• बैश के साथ प्रोग्राम कैसे करें: लॉजिकल ऑपरेटर्स और शेल एक्सपैंशन
• बैश के साथ प्रोग्राम कैसे करें: लूप्स

यह लेख श्रृंखला डेविड बोथ के तीन-भाग वाले लिनक्स सेल्फ-स्टडी कोर्स, Using and Administering Linux—Zero to SysAdmin के वॉल्यूम 2, अध्याय 10 पर आंशिक रूप से आधारित है।