फंक्शन्स किसी भी प्रोग्रामिंग भाषा में महत्वपूर्ण भूमिका निभाते हैं। कई वास्तविक प्रोग्रामिंग भाषाओं की तरह, bash में फंक्शन्स होते हैं जिनका उपयोग सीमित कार्यान्वयन के साथ किया जाता है।
फंक्शन्स क्या हैं?
प्रोग्रामिंग में, फंक्शन्स एक प्रोग्राम के नामित अनुभाग होते हैं जो एक विशिष्ट कार्य करते हैं। इस अर्थ में, एक फंक्शन एक प्रकार की प्रक्रिया या रूटीन है। जब एक फंक्शन को कॉल किया जाता है तो प्रोग्राम कोड के वर्तमान अनुभाग को छोड़ देता है और फंक्शन के अंदर पहली लाइन को निष्पादित करना शुरू करता है। जब भी दोहराव वाला कोड हो या जब कोई कार्य दोहराता हो, तो उसके बजाय फंक्शन का उपयोग करने पर विचार करें।
उदाहरण के लिए, उस मामले पर विचार करें जहां हमें किसी विशेष प्रोग्राम के कई चरणों में एक संख्या का फैक्टोरियल खोजने की आवश्यकता होती है। हर बार पूरे कोड (फैक्टोरियल की गणना के लिए) लिखने के बजाय, हम उस कोड के हिस्से को एक बार ब्लॉक के अंदर लिख सकते हैं जो फैक्टोरियल की गणना करता है और उसी को कई मौकों पर पुन: उपयोग कर सकते हैं।
हम फंक्शन्स क्यों लिखते हैं?
- यह कोड को पुन: उपयोग करने में मदद करता है।
- प्रोग्राम की पठनीयता में सुधार करता है।
- प्रोग्राम के अंदर वेरिएबल्स का कुशल उपयोग।
- हमें प्रोग्राम को भाग-दर-भाग टेस्ट करने की अनुमति देता है।
- प्रोग्राम को उप-चरणों के एक समूह के रूप में प्रदर्शित करता है।
शेल स्क्रिप्ट में फंक्शन्स
शेल स्क्रिप्ट में फंक्शन्स लिखने का सामान्य सिंटैक्स निम्नलिखित तरीकों को शामिल करता है।
function func_name { . . . commands . . . } or func_name ( ) { . . . commands . . . } ओपनिंग कर्ली ब्रेसेस का उपयोग दूसरी लाइन में भी किया जा सकता है। func_name ( ) { . . . commands . . . }
आप हमेशा इन फंक्शन ब्लॉक्स के अंदर वैध कमांड्स लिखने के लिए स्वतंत्र हैं जैसा कि हम सामान्य रूप से शेल स्क्रिप्ट में करते हैं। अब आइए एक छोटे फंक्शन के साथ एक सरल स्क्रिप्ट लिखने का प्रयास करें।
#!/bin/bash call_echo ( ) { echo 'This is inside function' } op=$1 if [ $# -ne 1 ]; then echo "Usage: $0 <1/0>" else if [ $1 = 0 ] ; then echo 'This is outside function' elif [ $1 = 1 ] ; then call_echo else echo 'Invalid argument' fi fi exit 0
फंक्शन परिभाषा को इसके पहले कॉल से पहले आना चाहिए। 'फंक्शन घोषित करने' जैसा कुछ नहीं है जिसे कॉल करने से पहले किया जाए। और हम हमेशा फंक्शन्स के अंदर फंक्शन्स को नेस्ट कर सकते हैं।
नोट:- खाली फंक्शन लिखने से हमेशा सिंटैक्स एरर होता है।
जब एक ही फंक्शन को कई बार परिभाषित किया जाता है, तो अंतिम संस्करण ही लागू होता है। एक उदाहरण लेते हैं।
#!/bin/bash func_same ( ) { echo 'First definition' } func_same ( ) { echo 'Second definition' } func_same exit 0
पैरामीटर लेने वाले और मान लौटाने वाले फंक्शन्स
आइए पैरामीटर लेने वाले और मान लौटाने वाले फंक्शन्स पर विचार करके गहराई से जाएं। फंक्शन से मान लौटाने के लिए हम 'return' शेल बिल्ट-इन का उपयोग करते हैं। सिंटैक्स इस प्रकार है।
func_name ( ) { . . . commands . . . return $ret_val }
इसी तरह हम स्पेस से अलग करके फंक्शन्स को आर्गुमेंट्स पास कर सकते हैं जैसा कि नीचे दिया गया है।
func_name $arg_1 $arg_2 $arg_3
फंक्शन के अंदर हम क्रम में आर्गुमेंट्स को $1, $2, $3 और इसी तरह एक्सेस कर सकते हैं। दो पूर्णांकों का अधिकतम खोजने के लिए फंक्शन का उपयोग करके अधिक स्पष्टता के लिए निम्नलिखित उदाहरण स्क्रिप्ट देखें।
#!/bin/bash USG_ERR=7 max_two ( ) { if [ "$1" -eq "$2" ] ; then echo 'Equal' exit 0 elif [ "$1" -gt "$2" ] ; then echo $1 else echo $2 fi } err_str ( ) { echo "Usage: $0 " exit $USG_ERR } NUM_1=$1 NUM_2=$2 x if [ $# -ne 2 ] ; then err_str elif [ `expr $NUM_1 : '[0-9]*'` -eq ${#NUM_1} ] ; then if [ `expr $NUM_2 : '[0-9]*'` -eq ${#NUM_2} ] ; then max_two $NUM_1 $NUM_2 else err_str fi else err_str fi exit 0
उपरोक्त थोड़ा जटिल दिखता है, लेकिन अगर हम लाइनों के माध्यम से पढ़ते हैं तो यह सरल है। पहले नेस्टेड if-else if लाइन्स वैलिडेशन उद्देश्यों के लिए यानी रेगुलर एक्सप्रेशन की मदद से आर्गुमेंट्स की संख्या और प्रकार की जांच करने के लिए। उसके बाद हम दो कमांड लाइन आर्गुमेंट्स के साथ फंक्शन को कॉल करते हैं और परिणाम वहीं प्रदर्शित करते हैं। ऐसा इसलिए है क्योंकि हम फंक्शन से बड़े इंटीजर नहीं लौटा सकते। इस समस्या को हल करने का एक और तरीका ग्लोबल वेरिएबल्स का उपयोग करके फंक्शन के अंदर परिणाम स्टोर करना है। नीचे दी गई स्क्रिप्ट इस विधि को समझाती है।
#!/bin/bash USG_ERR=7 ret_val= max_two ( ) { if [ "$1" -eq "$2" ] ; then echo 'Equal' exit 0 elif [ "$1" -gt "$2" ] ; then ret_val=$1 else ret_val=$2 fi } err_str ( ) { echo "Usage: $0 " exit $USG_ERR } NUM_1=$1 NUM_2=$2 if [ $# -ne 2 ] ; then err_str elif [ `expr $NUM_1 : '[0-9]*'` -eq ${#NUM_1} ] ; then if [ `expr $NUM_2 : '[0-9]*'` -eq ${#NUM_2} ] ; then max_two $NUM_1 $NUM_2 echo $ret_val else err_str fi else err_str fi exit 0
अब पिछले शेल स्क्रिप्टिंग श्रृंखला में समझाए गए कुछ रोमांचक समस्याओं को फंक्शन्स का उपयोग करके आज़माएं।
- बेसिक लिनक्स शेल स्क्रिप्टिंग भाषा टिप्स समझें - भाग I
- लिनक्स न्यूबीज के लिए शेल प्रोग्रामिंग सीखने के लिए 5 शेल स्क्रिप्ट्स - भाग II
- लिनक्स BASH स्क्रिप्टिंग की दुनिया में नौकायन - भाग III
- लिनक्स शेल प्रोग्रामिंग का गणितीय पहलू - भाग IV
- शेल स्क्रिप्टिंग भाषा में गणितीय अभिव्यक्तियों की गणना - भाग V
मैं अगले भाग में लोकल वेरिएबल्स, रिकर्सन आदि जैसे कार्यात्मक फीचर्स का उपयोग करने के बारे में अधिक जानकारी के साथ वापस आऊंगा। कमेंट्स के साथ अपडेट रहें।
