बैश स्क्रिप्टिंग में महारत हासिल करें: सिंटैक्स, टूल्स और सर्वोत्तम अभ्यास

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

टैब कम्पलीशन, कमांड-लाइन रिकॉल और एडिटिंग, और एलियास जैसे शॉर्टकट जैसी विशेषताएं एक शक्तिशाली शेल के रूप में इसके मूल्य में योगदान करती हैं। इसका डिफ़ॉल्ट कमांड-लाइन एडिटिंग मोड Emacs का उपयोग करता है, लेकिन मेरी पसंदीदा बैश विशेषताओं में से एक यह है कि मैं इसे Vi मोड में बदल सकता हूँ ताकि उन एडिटिंग कमांड्स का उपयोग कर सकूं जो पहले से ही मेरी मसल मेमोरी का हिस्सा हैं।

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

यह तीन-भागों की श्रृंखला कमांड-लाइन इंटरफेस (CLI) प्रोग्रामिंग भाषा के रूप में बैश के उपयोग का पता लगाती है। यह पहला लेख बैश के साथ कुछ सरल कमांड-लाइन प्रोग्रामिंग, वेरिएबल्स, और कंट्रोल ऑपरेटर्स को देखता है। अन्य लेख बैश फाइलों के प्रकारों; स्ट्रिंग, न्यूमेरिक, और विविध लॉजिकल ऑपरेटर्स जो एक्ज़ीक्यूशन-फ्लो कंट्रोल लॉजिक प्रदान करते हैं; विभिन्न प्रकार के शेल एक्सपैंशन; और for, while, और until लूप्स जो दोहराव वाले ऑपरेशन को सक्षम करते हैं, का पता लगाएंगे। वे उन कमांड्स को भी देखेंगे जो इन टूल्स के उपयोग को सरल और समर्थन करते हैं।

शेल

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

बैश का अर्थ है बॉर्न अगेन शेल क्योंकि बैश शेल पुराने बॉर्न शेल पर आधारित है जिसे स्टीवन बॉर्न ने 1977 में लिखा था। कई अन्य शेल्स उपलब्ध हैं, लेकिन ये चार हैं जिनका मैं सबसे अधिक सामना करता हूँ:

• csh: C भाषा के सिंटैक्स को पसंद करने वाले प्रोग्रामर्स के लिए C शेल
• ksh: कॉर्न शेल, जिसे डेविड कॉर्न ने लिखा था और यूनिक्स यूजर्स के बीच लोकप्रिय है
• tcsh: अधिक उपयोग-में-आसान सुविधाओं के साथ csh का एक संस्करण
• zsh: Z शेल, जो अन्य लोकप्रिय शेल्स की कई विशेषताओं को जोड़ता है

सभी शेल्स में बिल्ट-इन कमांड्स होती हैं जो कोर यूटिलिटीज द्वारा प्रदान की गई कमांड्स को पूरक या प्रतिस्थापित करती हैं। शेल के मैन पेज को खोलें और इसके द्वारा प्रदान की जाने वाली कमांड्स को देखने के लिए "BUILT-INS" सेक्शन ढूंढें।

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

ये सभी शेल्स कमांड इंटरप्रेटर्स के साथ-साथ प्रोग्रामिंग भाषाएं भी हैं। यहाँ बैश के अभिन्न अंग कुछ प्रोग्रामिंग कंस्ट्रक्ट्स और टूल्स का एक त्वरित दौरा है।

प्रोग्रामिंग भाषा के रूप में बैश

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

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

"एक प्रोग्राम" क्या है?

फ्री ऑन-लाइन डिक्शनरी ऑफ कंप्यूटिंग (FOLDOC) एक प्रोग्राम को परिभाषित करता है: "कंप्यूटर द्वारा निष्पादित निर्देश, भौतिक डिवाइस के विपरीत जिस पर वे चलते हैं।" प्रिंसटन यूनिवर्सिटी का वर्डनेट एक प्रोग्राम को परिभाषित करता है: "…निर्देशों का एक क्रम जिसे एक कंप्यूटर इंटरप्रेट और निष्पादित कर सकता है…" विकिपीडिया में कंप्यूटर प्रोग्राम के बारे में एक अच्छा प्रवेश भी है।

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

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

सरल CLI प्रोग्राम्स

सबसे सरल कमांड-लाइन प्रोग्राम एक या दो लगातार प्रोग्राम स्टेटमेंट्स होते हैं, जो संबंधित हो सकते हैं या नहीं, जो Enter कुंजी दबाने से पहले कमांड लाइन पर दर्ज किए जाते हैं। एक प्रोग्राम में दूसरा स्टेटमेंट, यदि है, तो पहले की क्रियाओं पर निर्भर हो सकता है, लेकिन ऐसा होना आवश्यक नहीं है।

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

कुछ बुनियादी सिंटैक्स

निम्नलिखित उदाहरण इस सिंटैक्स को स्पष्ट करेंगे। इस प्रोग्राम में एक स्पष्ट टर्मिनेटर के साथ एक सिंगल कमांड होती है:

[student@studentvm1 ~]$ echo "Hello world." ;
 Hello world.

यह ज्यादा प्रोग्राम जैसा नहीं लग सकता, लेकिन यह पहला प्रोग्राम है जिसे मैं हर नई प्रोग्रामिंग भाषा सीखने पर देखता हूँ। प्रत्येक भाषा के लिए सिंटैक्स थोड़ा अलग हो सकता है, लेकिन परिणाम समान होता है।

आइए इस तुच्छ लेकिन सर्वव्यापी प्रोग्राम पर थोड़ा विस्तार करें। आपके परिणाम मेरे से अलग होंगे क्योंकि मैंने अन्य प्रयोग किए हैं, जबकि आपके पास केवल डिफ़ॉल्ट डायरेक्टरीज और फाइलें हो सकती हैं जो पहली बार GUI डेस्कटॉप के माध्यम से अकाउंट में लॉग इन करने पर अकाउंट होम डायरेक्टरी में बनाई जाती हैं।

[student@studentvm1 ~]$ echo "My home directory." ; ls ;
 My home directory.
 chapter25 TestFile1.Linux dmesg2.txt Downloads newfile.txt softlink1 testdir6
 chapter26 TestFile1.mac dmesg3.txt file005 Pictures Templates testdir
 TestFile1 Desktop dmesg.txt link3 Public testdir Videos
 TestFile1.dos dmesg1.txt Documents Music random.txt testdir1

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

[student@studentvm1 ~]$ echo "My home directory." ; ls 

आउटपुट में कोई अंतर नहीं है।

वेरिएबल्स के बारे में कुछ

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

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

वेरिएबल्स को मान असाइन किए जाते हैं और CLI प्रोग्राम्स और स्क्रिप्ट्स में उन मानों को संदर्भित करने के लिए उपयोग किया जा सकता है। एक वेरिएबल का मान इसके नाम का उपयोग करके सेट किया जाता है लेकिन $ साइन से पहले नहीं। असाइनमेंट VAR=10 वेरिएबल VAR का मान 10 पर सेट करता है। वेरिएबल का मान प्रिंट करने के लिए, आप स्टेटमेंट echo $VAR का उपयोग कर सकते हैं। टेक्स्ट (यानी, नॉन-न्यूमेरिक) वेरिएबल्स से शुरू करें।

बैश वेरिएबल्स शेल एनवायरनमेंट का हिस्सा बन जाते हैं जब तक उन्हें अनसेट नहीं किया जाता।

एक ऐसे वेरिएबल के प्रारंभिक मान की जांच करें जिसे असाइन नहीं किया गया है; यह नल होना चाहिए। फिर वेरिएबल को एक मान असाइन करें और उसका मान सत्यापित करने के लिए प्रिंट करें। आप यह सब एक ही CLI प्रोग्राम में कर सकते हैं:

[student@studentvm1 ~]$ echo $MyVar ; MyVar="Hello World" ; echo $MyVar ;
 
 Hello World
 [student@studentvm1 ~]$

नोट: वेरिएबल असाइनमेंट का सिंटैक्स बहुत सख्त है। असाइनमेंट स्टेटमेंट में इक्वल (=) साइन के दोनों ओर कोई स्पेस नहीं होना चाहिए।

खाली लाइन इंगित करती है कि MyVar का प्रारंभिक मान नल है। वेरिएबल का मान बदलना और सेट करना उसी तरह किया जाता है। यह उदाहरण मूल और नए दोनों मानों को दिखाता है।

जैसा कि उल्लेख किया गया है, बैश इंटीजर अंकगणित गणना कर सकता है, जो एक सरणी में एक तत्व के स्थान के संदर्भ की गणना करने या सरल गणित समस्याओं को करने के लिए उपयोगी है। यह वैज्ञानिक कंप्यूटिंग या किसी भी चीज़ के लिए उपयुक्त नहीं है जिसके लिए दशमलव की आवश्यकता होती है, जैसे वित्तीय गणना। उन प्रकार की गणनाओं के लिए कहीं बेहतर टूल्स हैं।

यहाँ एक सरल गणना है:

[student@studentvm1 ~]$ Var1="7" ; Var2="9" ; echo "Result = $((Var1*Var2))"
 Result = 63

जब आप एक गणित ऑपरेशन करते हैं जिसके परिणामस्वरूप एक फ्लोटिंग-पॉइंट संख्या होती है तो क्या होता है?

[student@studentvm1 ~]$ Var1="7" ; Var2="9" ; echo "Result = $((Var1/Var2))"
 Result = 0
 [student@studentvm1 ~]$ Var1="7" ; Var2="9" ; echo "Result = $((Var2/Var1))"
 Result = 1
 [student@studentvm1 ~]$

परिणाम निकटतम इंटीजर होता है। ध्यान दें कि गणना echo स्टेटमेंट के भाग के रूप में की गई थी। बैश ऑर्डर ऑफ प्रेसिडेंस के कारण संलग्न echo कमांड से पहले गणित किया जाता है। विवरण के लिए बैश मैन पेज देखें और "precedence" खोजें।

कंट्रोल ऑपरेटर्स

शेल कंट्रोल ऑपरेटर्स दिलचस्प कमांड-लाइन प्रोग्राम्स आसानी से बनाने के लिए सिंटैक्टिकल ऑपरेटर्स में से एक हैं। CLI प्रोग्राम का सबसे सरल रूप केवल कमांड लाइन पर कई कमांड्स को एक क्रम में जोड़ना है:

command1 ; command2 ; command3 ; command4 ; . . . ; etc. ;

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

&& ऑपरेटर बस कहता है, "यदि command1 सफल है, तो command2 चलाएं। यदि command1 किसी भी कारण से विफल होता है, तो command2 को छोड़ दिया जाता है।" वह सिंटैक्स इस तरह दिखता है:

command1 && command2

अब, कुछ कमांड्स को देखें जो एक नई डायरेक्टरी बनाएंगे और—यदि सफल होते हैं—तो उसे प्रेजेंट वर्किंग डायरेक्टरी (PWD) बना देंगे। सुनिश्चित करें कि आपकी होम डायरेक्टरी (~) PWD है। पहले इसे /root में आज़माएं, एक डायरेक्टरी जिस तक आपकी पहुंच नहीं है:

[student@studentvm1 ~]$ Dir=/root/testdir ; mkdir $Dir/ && cd $Dir
 mkdir: cannot create directory '/root/testdir/': Permission denied
 [student@studentvm1 ~]$

त्रुटि mkdir कमांड द्वारा उत्सर्जित की गई थी। आपको यह त्रुटि नहीं मिली कि फाइल नहीं बनाई जा सकी क्योंकि डायरेक्टरी का निर्माण विफल हो गया। && कंट्रोल ऑपरेटर ने नॉन-जीरो रिटर्न कोड को महसूस किया, इसलिए touch कमांड को छोड़ दिया गया। && कंट्रोल ऑपरेटर का उपयोग touch कमांड को चलने से रोकता है क्योंकि डायरेक्टरी बनाने में त्रुटि हुई थी। इस प्रकार का कमांड-लाइन प्रोग्राम फ्लो कंट्रोल त्रुटियों को बढ़ने और चीजों को वास्तव में गड़बड़ करने से रोक सकता है। लेकिन अब थोड़ा और जटिल होने का समय है।

|| कंट्रोल ऑपरेटर आपको एक और प्रोग्राम स्टेटमेंट जोड़ने की अनुमति देता है जो तब निष्पादित होता है जब प्रारंभिक प्रोग्राम स्टेटमेंट शून्य से अधिक रिटर्न कोड देता है। बुनियादी सिंटैक्स इस तरह दिखता है:

command1 || command2 

यह सिंटैक्स पढ़ता है, "यदि command1 विफल होता है, तो command2 निष्पादित करें।" इसका तात्पर्य है कि यदि command1 सफल होता है, तो command2 को छोड़ दिया जाता है। एक नई डायरेक्टरी बनाने का प्रयास करके इसे आज़माएं:

[student@studentvm1 ~]$ Dir=/root/testdir ; mkdir $Dir || echo "$Dir was not created."
 mkdir: cannot create directory '/root/testdir': Permission denied
 /root/testdir was not created.
 [student@studentvm1 ~]$

यह वही है जिसकी आप अपेक्षा करेंगे। क्योंकि नई डायरेक्टरी नहीं बनाई जा सकी, पहली कमांड विफल हो गई, जिसके परिणामस्वरूप दूसरी कमांड का निष्पादन हुआ।

इन दो ऑपरेटर्स को संयोजित करने से दोनों का सर्वोत्तम लाभ मिलता है। जब && और || कंट्रोल ऑपरेटर्स का उपयोग किया जाता है तो कुछ फ्लो कंट्रोल का उपयोग करने वाला कंट्रोल ऑपरेटर सिंटैक्स इस सामान्य रूप को लेता है:

preceding commands ; command1 && command2 || command3 ; following commands

इस सिंटैक्स को इस तरह बताया जा सकता है: "यदि command1 रिटर्न कोड 0 के साथ समाप्त होता है, तो command2 निष्पादित करें, अन्यथा command3 निष्पादित करें।" इसे आज़माएं:

[student@studentvm1 ~]$ Dir=/root/testdir ; mkdir $Dir && cd $Dir || echo "$Dir was not created."
 mkdir: cannot create directory '/root/testdir': Permission denied
 /root/testdir was not created.
 [student@studentvm1 ~]$

अब अंतिम कमांड को फिर से आज़माएं लेकिन /root डायरेक्टरी के बजाय अपनी होम डायरेक्टरी का उपयोग करके। आपको इस डायरेक्टरी को बनाने की अनुमति होगी:

[student@studentvm1 ~]$ Dir=~/testdir ; mkdir $Dir && cd $Dir || echo "$Dir was not created."
 [student@studentvm1 testdir]$

कंट्रोल ऑपरेटर सिंटैक्स, जैसे command1 && command2, काम करता है क्योंकि हर कमांड शेल को एक रिटर्न कोड (RC) भेजती है जो इंगित करता है कि क्या यह सफलतापूर्वक पूरा हुआ या निष्पादन के दौरान किसी प्रकार की विफलता हुई। परंपरा के अनुसार, शून्य (0) का RC सफलता को इंगित करता है, और कोई भी पॉजिटिव नंबर किसी प्रकार की विफलता को इंगित करता है। सिसएडमिन्स द्वारा उपयोग किए जाने वाले कुछ टूल्स केवल विफलता को इंगित करने के लिए एक (1) लौटाते हैं, लेकिन कई विफलता के प्रकार को इंगित करने के लिए अन्य कोड्स का उपयोग करते हैं।

बैश शेल वेरिएबल $? में अंतिम कमांड से RC होता है। इस RC को स्क्रिप्ट द्वारा, कमांड्स की सूची में अगली कमांड द्वारा, या यहां तक कि सिसएडमिन द्वारा सीधे बहुत आसानी से जांचा जा सकता है। यह RC हमेशा उस अंतिम कमांड के लिए होगा जो आपके द्वारा इसे देखने से पहले चली थी। एक सरल कमांड चलाकर और तुरंत RC की जांच करके शुरू करें।

[student@studentvm1 testdir]$ ll ; echo "RC = $?"
 total 1264
 drwxrwxr-x 2 student student 4096 Mar 2 08:21 chapter25
 drwxrwxr-x 2 student student 4096 Mar 21 15:27 chapter26
 -rwxr-xr-x 1 student student 92 Mar 20 15:53 TestFile1
 <snip>
 drwxrwxr-x. 2 student student 663552 Feb 21 14:12 testdir
 drwxr-xr-x. 2 student student 4096 Dec 22 13:15 Videos
 RC = 0
 [student@studentvm1 testdir]$

इस मामले में, RC शून्य है, जिसका अर्थ है कि कमांड सफलतापूर्वक पूरी हुई। अब उसी कमांड को रूट की होम डायरेक्टरी पर आज़माएं, एक डायरेक्टरी जिस तक आपकी अनुमति नहीं है:

[student@studentvm1 testdir]$ ll /root ; echo "RC = $?"
 ls: cannot open directory '/root': Permission denied
 RC = 2
 [student@studentvm1 testdir]$

इस मामले में, RC दो है; इसका अर्थ है कि एक नॉन-रूट यूजर को उस डायरेक्टरी तक पहुंचने की अनुमति नहीं दी गई जिस तक यूजर को पहुंच की अनुमति नहीं है। कंट्रोल ऑपरेटर्स प्रोग्राम एक्ज़ीक्यूशन के क्रम को बदलने में सक्षम बनाने के लिए इन RCs का उपयोग करते हैं।

सारांश

इस लेख ने प्रोग्रामिंग भाषा के रूप में बैश को देखा और इसके बुनियादी सिंटैक्स के साथ-साथ कुछ बुनियादी टूल्स का पता लगाया। इसने दिखाया कि STDOUT पर डेटा कैसे प्रिंट किया जाता है और वेरिएबल्स और कंट्रोल ऑपरेटर्स का उपयोग कैसे किया जाता है। इस श्रृंखला का अगला लेख कई बैश लॉजिकल ऑपरेटर्स को देखता है जो निर्देश निष्पादन के प्रवाह को नियंत्रित करते हैं।