बैश स्क्रिप्ट क्या है?

What Is Bash Script

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

बैश क्यों उपयोगी है और यह किसके लिए उपयोगी है?

यदि आप अपने ओएस पर अधिक नियंत्रण चाहते हैं और ओएस से संबंधित विभिन्न कार्य करना चाहते हैं तो बैश आपका रास्ता है। बैश द्वारा, हम न केवल स्क्रिप्टिंग भाषा को संदर्भित करते हैं बल्कि लिनक्स ऑपरेटिंग सिस्टम के साथ आने वाले टूल को भी संदर्भित करते हैं। लिनक्स पर हर एक टूल का अपना काम होता है और प्रत्येक अलग-अलग कार्य करता है। बैश वास्तव में तब उपयोगी होता है जब आपको उन सभी उपकरणों को संयोजित करने और उन्हें एक साथ इस तरह से जोड़ने की आवश्यकता होती है कि वे सभी एक कार्य को पूरा करने के लिए सद्भाव में काम करते हैं जो अन्यथा करना वास्तव में मुश्किल है। उदाहरण के लिए, लिनक्स ओएस के साथ कुछ भी करना अन्य प्रोग्रामिंग भाषाओं जैसे कि पायथन या पर्ल में भी किया जा सकता है लेकिन ओएस से संबंधित विभिन्न कार्यों को पूरा करना बहुत कठिन है। लिनक्स ओएस से संबंधित कुछ भी करने का एक सरल, काला और सफेद और आसान तरीका बैश का उपयोग करना है। जो कोई भी ऐसे कार्य करना चाहता है जिसमें Linux OS उपकरण (जैसे ls, cd, cat, touch, grep, आदि) शामिल हैं, उसके लिए किसी अन्य प्रोग्रामिंग भाषा के बजाय बैश सीखना वास्तव में उपयोगी है।







बैश अन्य प्रोग्रामिंग भाषाओं की तुलना कैसे करता है?

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



बैश स्क्रिप्ट कैसे बनाएं और चलाएं?

बैश स्क्रिप्ट बनाने के लिए, आपको फ़ाइल नाम के अंत में .sh के विस्तार के साथ पहले एक टेक्स्ट फ़ाइल बनानी होगी। आप टर्मिनल का उपयोग करके बैश स्क्रिप्टिंग फ़ाइल बना सकते हैं।



$स्पर्शscript.sh


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





#!/बिन/बैश


यह प्रत्येक बैश स्क्रिप्टिंग फ़ाइल के लिए एक मानक प्रथम-पंक्ति है जो इसे बैश स्क्रिप्ट के रूप में पहचाने जाने में मदद करती है। पहली पंक्ति में #!/Bin/bash नहीं होने वाली किसी भी स्क्रिप्ट को बैश स्क्रिप्ट नहीं माना जाएगा, इसलिए इस पंक्ति को प्रत्येक स्क्रिप्ट के शीर्ष पर जोड़ना सुनिश्चित करें। एक बार जब आप इस लाइन को जोड़ लेते हैं, तो अब आप स्क्रिप्ट में लिखना शुरू कर सकते हैं। उदाहरण के लिए, मैं यहां एक साधारण इको कमांड लिखूंगा:

$फेंक दियायह है LinuxHint, बेस्ट लर्निंग प्लेटफॉर्मके लियेदे घुमा के


एक बार जब आप यह कमांड लिख लेते हैं, तो अब आप इसे सेव करके आगे बढ़ सकते हैं, और अपने टर्मिनल पर वापस जा सकते हैं। अपने टर्मिनल में लिखें:



$रास -तक


आप सफेद रंग में लिखा हुआ 'script.sh' देख सकते हैं जो इस बात का संकेत है कि स्क्रिप्ट एक गैर-निष्पादन योग्य फ़ाइल है क्योंकि निष्पादन योग्य फ़ाइलें आमतौर पर हरे रंग में होती हैं। इसके अलावा, बाईं ओर एक नज़र डालें जहाँ हम -rw-r-r- जैसा एक पैटर्न देख सकते हैं जो दर्शाता है कि फ़ाइल केवल पढ़ने योग्य और लिखने योग्य है।
'आरडब्ल्यू' वाला पहला भाग मालिक के लिए वर्तमान उपयोगकर्ता की अनुमति है।

'r' वाला दूसरा भाग उस समूह के लिए अनुमति है जिसमें हमारे कई उपयोगकर्ता हैं।

जबकि 'r' वाला तीसरा भाग जनता के लिए अनुमति है जिसका अर्थ है कि उल्लिखित फ़ाइल के लिए कोई भी इन अनुमतियों को प्राप्त कर सकता है।

'आर' पढ़ने की अनुमति के लिए है, 'डब्ल्यू' लिखने की अनुमति के लिए है, 'एक्स' निष्पादन योग्य अनुमतियों के लिए है। स्पष्ट रूप से, हम x को 'script.sh' के सामने नहीं देखते हैं। निष्पादन योग्य अनुमतियाँ जोड़ने के लिए, इसे करने के दो तरीके हैं।

विधि १

इस पद्धति में, आप '+x' के साथ एक साधारण chmod कमांड लिख सकते हैं और यह निष्पादन योग्य अनुमतियों को जोड़ देगा।

$चामोद+ एक्स स्क्रिप्ट.sh


हालाँकि, यह निष्पादन योग्य अनुमति देने का सबसे कुशल तरीका नहीं है क्योंकि यह न केवल मालिक को बल्कि समूह और जनता को भी निष्पादन योग्य अनुमति देता है जो हम निश्चित रूप से सुरक्षा कारणों से नहीं चाहते हैं। जरा देखो तो:

विधि 2

इस पद्धति में, आप किसी फ़ाइल की अनुमतियों को निर्धारित करने के लिए संख्याओं का उपयोग कर सकते हैं। इससे पहले कि हम इसमें कूदें, मैं आपको एक संक्षिप्त विचार देना चाहता हूं कि उन नंबरों का क्या अर्थ है और आप अनुमतियों में हेरफेर करने के लिए उनका उपयोग कैसे कर सकते हैं।
पढ़ें = 4
लिखना = 2
निष्पादित = 1
अनुमति संख्या chmod कमांड के बाद तीन अंकों में होगी और प्रत्येक अंक स्वामी, समूह और अन्य (सार्वजनिक) की अनुमतियों का प्रतिनिधित्व करता है। उदाहरण के लिए, मालिक को पढ़ने, लिखने और निष्पादन की अनुमति देने के लिए और समूह और अन्य लोगों को पढ़ने की अनुमति कुछ इस तरह होगी:

$चामोद 744script.sh


यदि आप नोटिस कर सकते हैं, तो आपको पता चलेगा कि हमने पहले अंक में मालिक के लिए 4+2+1=7 के रूप में पढ़ने, लिखने और निष्पादित संख्याओं को जोड़ा है, और समूह और अन्य के लिए हम पढ़ने के अंक का उपयोग करते हैं यानी 4.

एक बैश स्क्रिप्ट चलाएँ

अब आखिरकार हम उस मुकाम पर पहुंच गए हैं जहां हम बैश स्क्रिप्ट चला सकते हैं। अपनी बैश स्क्रिप्ट चलाने के लिए, आपको यह सुनिश्चित करना होगा कि आप वर्तमान कार्यशील निर्देशिका में हैं जहाँ आपकी स्क्रिप्ट रहती है। यह अनिवार्य नहीं है लेकिन इस तरह यह आसान है क्योंकि आपको पूरा रास्ता नहीं लिखना है। एक बार कर लेने के बाद, अब आगे बढ़ें और अपने टर्मिनल ./nameofscript.sh में लिखें। हमारे मामले में, स्क्रिप्ट का नाम 'script.sh' है, इसलिए हम लिखेंगे:

$./script.sh

बैश स्क्रिप्ट के 3 सरल उदाहरण

हैलो लिनक्ससंकेत
सबसे पहले, हम वर्तमान कार्यशील निर्देशिका में एक बैश फ़ाइल बनाएंगे:

$नैनोF_script.sh


फ़ाइल के अंदर आपको निम्नलिखित लिखना होगा:

#!/बिन/बैश
फेंक दिया 'हैलो लिनक्सहिंट'


एक बार जब आप इसे लिख लेते हैं, तो अब फ़ाइल परिवर्तन लिखने के लिए Ctrl + O दबाने का प्रयास करें, यदि आप नाम को वही हिट एंटर रखना चाहते हैं, अन्यथा नाम संपादित करें, और फिर एंटर दबाएं। अब नैनो एडिटर से बाहर निकलने के लिए Ctrl+X दबाएं। अब आप अपनी वर्तमान निर्देशिका में F_script.sh नाम की एक फ़ाइल देखेंगे।
इस फ़ाइल को चलाने के लिए आप इसे निष्पादन योग्य बनाने के लिए इसकी अनुमतियों को बदल सकते हैं या आप लिख सकते हैं:

$दे घुमा केF_script.sh


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

#!/बिन/बैश
फेंक दिया 'अगली पंक्ति पर प्रिंट करें'

इसे सहेजे जाने के बाद, यदि हम इसे चलाते हैं:

$दे घुमा केF_script.sh


अगर हम '-n' फ्लैग को इको के साथ इस्तेमाल करते हैं तो यह उसी लाइन पर प्रिंट होता है।

#!/बिन/बैश
फेंक दिया -एन 'एक ही लाइन पर प्रिंट करें'

इसे सहेजे जाने के बाद, यदि हम इसे चलाते हैं:

$दे घुमा केF_script.sh


इसी तरह, यदि हम दोहरे उद्धरण चिह्नों के भीतर ' ' या ' ' का उपयोग करते हैं, तो यह जैसा है वैसा ही प्रिंट होगा।

#!/बिन/बैश
फेंक दिया 'एनप्रिंट करेंटीएक ही पंक्तिएन'


हालाँकि, यदि हम '-e' ध्वज का उपयोग करते हैं, तो यह न केवल चला जाता है बल्कि यह और भी लागू होता है और आप नीचे दिए गए आउटपुट में परिवर्तन देख सकते हैं:

#!/बिन/बैश
फेंक दिया -और 'एनप्रिंट करेंटीएक ही पंक्तिएन'


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

सिंगल लाइन टिप्पणियाँ
एकल-पंक्ति टिप्पणियों में, हम एक '#' चिह्न का उपयोग करते हैं जो पूरी पंक्ति पर टिप्पणी करने में मदद करता है। लाइन पर '#' के बाद लिखी गई किसी भी चीज़ को एक टिप्पणी के रूप में माना जाएगा और जब हम स्क्रिप्ट निष्पादित कर रहे हों तो उसका कोई वास्तविक मूल्य नहीं होगा। इस सिंगल लाइन कमेंट का उपयोग कोड के तर्क और समझ को किसी ऐसे व्यक्ति तक पहुंचाने के लिए किया जा सकता है, जिसके पास कोड तक पहुंच है।

#!/बिन/बैश
फेंक दिया -और 'एनप्रिंट करेंटीएक ही पंक्तिएन'
#यह स्क्रिप्ट हमें /n और /t . के / संयोजन को लागू करने में मदद करती है



मल्टी लाइन टिप्पणियाँ
मान लीजिए कि आप अपनी स्क्रिप्ट में सौ पंक्तियों पर टिप्पणी करना चाहते हैं। उस स्थिति में, आपके लिए एकल-पंक्ति टिप्पणियों का उपयोग करना कठिन होगा। आप हर लाइन पर # लगाकर अपना समय बर्बाद नहीं करना चाहते। हम ':' और फिर 'जो भी टिप्पणियाँ' का उपयोग कर सकते हैं। यह आपको केवल 3 प्रतीकों में टाइप करके कई पंक्तियों पर टिप्पणी करने में मदद करेगा जो उपयोगी और उपयोगी हैं।

#!/बिन/बैश'
: 'यह स्क्रिप्ट है जो सुनिश्चित करती है
वह और काम करता है और लागू हो जाता है
मेंएक तरीका है कि हमारे पास आवश्यक आउटपुट है '
फेंक दिया -और 'एनप्रिंट करेंटीएक ही पंक्तिएन'



Linuxhint.com पर बैश स्क्रिप्ट के 30 उदाहरण देखें:

30 बैश स्क्रिप्ट उदाहरण

बैश स्क्रिप्टिंग में 6 सबसे महत्वपूर्ण सबक

1. सशर्त वक्तव्य
सशर्त विवरण निर्णय लेने में एक बहुत ही उपयोगी उपकरण है। यह प्रोग्रामिंग भाषाओं में व्यापक रूप से उपयोग किया जाता है। अधिक बार, हमें कुछ शर्तों के आधार पर निर्णय लेने की आवश्यकता होती है। सशर्त बयान दी गई शर्त का मूल्यांकन करता है और निर्णय लेता है। बैश में, हम किसी अन्य प्रोग्रामिंग भाषा की तरह सशर्त कथन का भी उपयोग करते हैं। बैश में कंडीशनल स्टेटमेंट का उपयोग करने का सिंटैक्स अन्य प्रोग्रामिंग भाषाओं से थोड़ा अलग है। if कंडीशन बैश और अन्य सामान्य प्रयोजन प्रोग्रामिंग भाषाओं में सबसे अधिक इस्तेमाल किया जाने वाला सशर्त कथन है। अगर शर्त दी गई स्थिति का मूल्यांकन करती है और निर्णय लेती है। दी गई स्थिति को परीक्षण व्यंजक भी कहते हैं। बैश में अगर स्थिति का उपयोग करने के कई तरीके हैं। if कंडीशन का उपयोग अन्य ब्लॉक के साथ किया जाता है। मामले में, यदि दी गई शर्त सत्य है, तो if ब्लॉक के अंदर के बयानों को निष्पादित किया जाता है, अन्यथा अन्य ब्लॉक को निष्पादित किया जाता है। बैश में if कंडीशन स्टेटमेंट का उपयोग करने के कई तरीके हैं जो निम्नलिखित हैं:

  1. अगर बयान
  2. अगर कोई और बयान
  3. नेस्टेड अगर बयान
  4. अगर एलिफ स्टेटमेंट

अगर बयान
यदि कथन केवल दी गई स्थिति का मूल्यांकन करता है, यदि दी गई स्थिति सत्य है, तो यदि ब्लॉक के अंदर कथन या आदेश निष्पादित किए जाते हैं, अन्यथा कार्यक्रम समाप्त हो जाता है। बैश में, यदि शर्त if कीवर्ड से शुरू होती है और fi कीवर्ड के साथ समाप्त होती है। तत्कालीन कीवर्ड का उपयोग स्टेटमेंट या कमांड के ब्लॉक को परिभाषित करने के लिए किया जाता है जो एक निश्चित स्थिति के सही होने पर निष्पादित होते हैं। आइए एक वेरिएबल घोषित करें और वैरिएबल के मान का मूल्यांकन करने के लिए if कंडीशन का उपयोग करें कि यह 10 से अधिक है या नहीं। -gt का उपयोग स्थिति से अधिक का मूल्यांकन करने के लिए किया जाता है, जबकि -lt का उपयोग स्थिति से कम का मूल्यांकन करने के लिए किया जाता है।

#!/बिन/बैश
कहां=100
#अगर शर्त घोषित करना
अगर [ $ वार -जीटी 10 ]
फिर
फेंक दिया 'NS$ वार10' से बड़ा है
#अगर शर्त खत्म करना
होना


अगर कोई और बयान
यदि अन्य कथन का उपयोग सशर्त कथन के रूप में भी किया जाता है। यदि दी गई शर्त सत्य है तो if कंडीशन निष्पादित होने के बाद स्टेटमेंट या कमांड। अन्यथा, अन्य ब्लॉक निष्पादित किया जाता है यदि दी गई शर्त सत्य नहीं है। अन्य ब्लॉक के बाद अगर ब्लॉक होता है और अन्य कीवर्ड से शुरू होता है।

#!/बिन/बैश
कहां=7
#अगर शर्त घोषित करना
अगर [ $ वार -जीटी 10 ]
फिर
फेंक दिया 'NS$ वार10' से बड़ा है
#अन्यथा ब्लॉक घोषित करना
अन्यथा
फेंक दिया 'NS$ वार10' से कम है
#अगर शर्त खत्म करना
होना


यदि स्थिति का उपयोग करके एकाधिक स्थितियों का मूल्यांकन किया जा सकता है। हम और ऑपरेटर (&) और या ऑपरेटर (II) का उपयोग सिंगल if स्टेटमेंट के अंदर कई स्थितियों का मूल्यांकन करने के लिए कर सकते हैं।

#!/बिन/बैश
कहां=बीस
#अगर शर्त घोषित करना
अगर [[ $ वार -जीटी 10 && $ वार -एलटीई 100 ]]
फिर
फेंक दिया 'NS$ वार10 से अधिक और 100 से कम है'
#अन्यथा ब्लॉक घोषित करना
अन्यथा
फेंक दिया 'शर्त पूरी नहीं होती'
#अगर शर्त खत्म करना
होना


नेस्टेड अगर बयान
नेस्टेड अगर स्टेटमेंट में, हमारे पास एक स्टेटमेंट के अंदर एक स्टेटमेंट होता है। पहले यदि कथन का मूल्यांकन किया जाता है, यदि यह सत्य है तो दूसरे यदि कथन का मूल्यांकन किया जाता है।

#!/बिन/बैश
कहां=बीस
#अगर शर्त घोषित करना
अगर [[ $ वार -जीटी 10 ]]
फिर
#अगर कंडीशन दूसरे के अंदर है तो कंडीशन
अगर [ $ वार -एलटीई 100 ]
फिर
फेंक दिया 'NS$ वार10 से अधिक और 100 से कम है'
#अन्यथा ब्लॉक घोषित करना
अन्यथा
फेंक दिया 'शर्त पूरी नहीं होती'
#अगर शर्त खत्म करना
होना
अन्यथा
फेंक दिया 'NS$ वार10' से कम है
होना


अगर एलिफ स्टेटमेंट
if elif स्टेटमेंट का उपयोग कई स्थितियों का मूल्यांकन करने के लिए किया जाता है। पहली शर्त if ब्लॉक से शुरू होती है और अन्य शर्तों के बाद elif कीवर्ड होता है। आइए पिछले चर संख्या उदाहरण पर विचार करें और हमारी बैश स्क्रिप्ट में if elif स्टेटमेंट को लागू करें। Eq का उपयोग बराबर ऑपरेटर के रूप में किया जाता है।

#!/बिन/बैश
कहां=बीस
#अगर शर्त घोषित करना
अगर [[ $ वार -ईक्यू 1 ]]
फिर
फेंक दिया 'परिवर्तनीय मान 1 के बराबर है'
एलिफ [[ $ वार -ईक्यू 2 ]]
फिर
फेंक दिया 'परिवर्तनीय मान 2 के बराबर है'
एलिफ [[ $ वार -ईक्यू 3 ]]
फिर
फेंक दिया 'परिवर्तनीय मान 2 के बराबर है'
एलिफ [[ $ वार -जीटी 5 ]]
फिर
फेंक दिया 'परिवर्तनीय मान 5 से अधिक है'
होना


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

जबकि लूप
जबकि लूप एक ही स्टेटमेंट या कमांड को बार-बार निष्पादित करता है। यह कंडीशन का मूल्यांकन करता है, और स्टेटमेंट्स या कमांड्स को तब तक रन करता है जब तक कि कंडीशन सही न हो जाए।
यह बैश में थोड़ी देर के लूप का उपयोग करने का मूल सिंटैक्स है।

जबकि [हालत या परीक्षण अभिव्यक्ति]
करना
बयान
किया हुआ

हमारी script.sh फ़ाइल में जबकि लूप को लागू करते हैं। हमारे पास एक वैरिएबल VAR है जिसका मान शून्य के बराबर है। जबकि लूप में, हमने एक शर्त रखी है, कि लूप तब तक चलना चाहिए जब तक कि VAR का मान 20 से कम न हो। प्रत्येक पुनरावृत्ति के बाद चर मान 1 से बढ़ जाता है। तो, इस मामले में, लूप तब तक क्रियान्वित करना शुरू कर देगा जब तक कि चर मान 20 से कम न हो।

#!/बिन/बैश
कहां=0
जबकि [ $ वार -एलटीई बीस ]
करना
फेंक दिया 'चर का वर्तमान मान है$ वार'
#VAR . में मान को 1 से बढ़ाना
कहां= $((वार +1))
किया हुआ


लूप के लिए
लूप के लिए प्रत्येक प्रोग्रामिंग भाषा में सबसे अधिक इस्तेमाल किया जाने वाला लूप है। इसका उपयोग पुनरावृत्त कार्य को निष्पादित करने के लिए किया जाता है। दोहराए जाने वाले कार्यों को करने का यह सबसे अच्छा तरीका है। आइए हमारी script.sh फ़ाइल में लूप के लिए घोषित करें और इसे दोहराए जाने वाले कार्य को करने के लिए उपयोग करें।

#!/बिन/बैश
कहां=0
के लिये (( मैं==0; मैं<बीस; मैं++))
करना
फेंक दिया 'नमस्कार और linuxhint में आपका स्वागत है'
#चर को बढ़ाना i
मैं= $((मैं+1))
किया हुआ
फेंक दिया 'यह लूप के लिए अंत है'


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

जब तक [हालत]
करना
बयान
आदेशों
किया हुआ

आइए हमारी script.sh फ़ाइल में लूप तक लागू करें। जब तक स्थिति गलत न हो तब तक लूप चलेगा (चर का मान 20 से कम है)

#!/बिन/बैश
कहां=0
जब तक [ $ वार -जीटी बीस ]
करना
फेंक दिया 'नमस्कार और linuxhint में आपका स्वागत है'
#चर को बढ़ाना i
कहां= $((वार +1))
किया हुआ
फेंक दिया 'यह लूप तक का अंत है'


3. उपयोगकर्ता से पढ़ना और उसे स्क्रीन पर लिखना
बैश उपयोगकर्ता को टर्मिनल पर कुछ स्ट्रिंग मान या डेटा दर्ज करने की स्वतंत्रता देता है। उपयोगकर्ता द्वारा दर्ज की गई स्ट्रिंग या डेटा को टर्मिनल से पढ़ा जा सकता है, इसे फ़ाइल में संग्रहीत किया जा सकता है, और टर्मिनल पर मुद्रित किया जा सकता है। बैश फ़ाइल में, उपयोगकर्ता से इनपुट का उपयोग करके पढ़ा जा सकता है पढ़ना कीवर्ड और हम इसे एक वेरिएबल में स्टोर करते हैं। परिवर्तनीय सामग्री को इको कमांड का उपयोग करके टर्मिनल पर प्रदर्शित किया जा सकता है।

#!/बिन/बैश
फेंक दिया 'टर्मिनल पर कुछ लिखें'
#VAR . में दर्ज किए गए मान को संग्रहीत करना
पढ़नाकहां
फेंक दिया 'आपने दर्ज किया:$ वार'


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

#!/बिन/बैश
पढ़ना -पी 'ईमेल दर्ज करें:'ईमेल
फेंक दिया 'पास वर्ड दर्ज करें'
पढ़ना -एसपासवर्ड


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

पाठ फ़ाइलें लिखना
डेटा को विभिन्न तरीकों से फ़ाइल में लिखा जा सकता है:

  • समकोण ब्रैकेट या अधिक से अधिक चिह्न (>) का उपयोग करके
  • डबल समकोण ब्रैकेट (>>) का उपयोग करके
  • टी कमांड का उपयोग करके

डेटा लिखने के लिए राइट एंजेल ब्रैकेट साइन (>)
टेक्स्ट फ़ाइल में डेटा लिखने के लिए यह सबसे अधिक इस्तेमाल किया जाने वाला तरीका है। हम डेटा लिखते हैं और फिर > चिह्न लगाते हैं। > साइन टेक्स्ट फाइल की ओर इशारा करता है जहां हमें डेटा स्टोर करना होता है। हालाँकि, यह फ़ाइल को संलग्न नहीं करता है और फ़ाइल के पिछले डेटा को पूरी तरह से नए डेटा से बदल दिया जाता है।

#!/बिन/बैश
#उपयोगकर्ता टेक्स्ट फ़ाइल नाम दर्ज करता है
पढ़ना -पी 'फ़ाइल नाम दर्ज करें:'फ़ाइल
#उपयोगकर्ता टेक्स्ट फ़ाइल में संग्रहीत करने के लिए डेटा दर्ज करता है
पढ़ना -पी 'फ़ाइल में दर्ज करने के लिए डेटा लिखें:'आंकड़े
#पाठ फ़ाइल में डेटा संग्रहीत करना
# > फ़ाइल नाम की ओर इशारा करता है।
फेंक दिया $डेटा > $फ़ाइल


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

#!/बिन/बैश
#उपयोगकर्ता टेक्स्ट फ़ाइल नाम दर्ज करता है
पढ़ना -पी 'फ़ाइल नाम दर्ज करें:'फ़ाइल
#फाइल में कमांड आउटपुट को स्टोर करना
रास -तक >> $फ़ाइल



टेक्स्ट फ़ाइल में डेटा लिखने के लिए टी कमांड का उपयोग करना
बैश में टी कमांड का उपयोग कमांड के आउटपुट को टेक्स्ट फाइल में लिखने के लिए किया जाता है। यह टर्मिनल पर कमांड के आउटपुट को प्रिंट करता है और साथ ही इसे टेक्स्ट फाइल में स्टोर करता है।

#!/बिन/बैश
#उपयोगकर्ता टेक्स्ट फ़ाइल नाम दर्ज करता है
पढ़ना -पी 'फ़ाइल नाम दर्ज करें:'फ़ाइल
# टी कमांड का उपयोग करके फाइल में कमांड आउटपुट को स्टोर करना
रास -तक | टी $फ़ाइल


टी कमांड डिफ़ॉल्ट रूप से फ़ाइल के मौजूदा डेटा को अधिलेखित कर देता है। हालाँकि, -a टी कमांड वाले विकल्प का उपयोग फ़ाइल को जोड़ने के लिए किया जा सकता है।

#!/बिन/बैश
#उपयोगकर्ता टेक्स्ट फ़ाइल नाम दर्ज करता है
पढ़ना -पी 'फ़ाइल नाम दर्ज करें:'फ़ाइल
# टी कमांड का उपयोग करके फाइल में कमांड आउटपुट को स्टोर करना
रास -तक | टी -प्रति $फ़ाइल


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

#!/बिन/बैश
#उपयोगकर्ता टेक्स्ट फ़ाइल नाम दर्ज करता है
पढ़ना -पी 'फ़ाइल नाम दर्ज करें:'फ़ाइल
#पाठ फ़ाइल से डेटा पढ़ना
बिल्ली $फ़ाइल


5. बैश से अन्य प्रोग्राम चलाना
बैश स्क्रिप्ट से अन्य प्रोग्राम चलाने का अधिकार देता है। बैश से अन्य प्रोग्राम चलाने के लिए हम exec कमांड का उपयोग करते हैं। निष्पादन कमांड पिछली प्रक्रिया को वर्तमान प्रक्रिया से बदल देता है और वर्तमान कार्यक्रम को लॉन्च करता है। उदाहरण के लिए, हम बैश स्क्रिप्ट से नैनो, जीएडिट या विम संपादक खोल सकते हैं।

#!/बिन/बैश
#Bash से नैनो संपादक चल रहा है
कार्यकारी नैनो

#!/बिन/बैश
#बाश से जीएडिट चल रहा है
कार्यकारीएडिट

इसी तरह, हम ब्राउज़र एप्लिकेशन को बैश से भी चला सकते हैं। आइए मोज़िला फ़ायरफ़ॉक्स ब्राउज़र चलाते हैं।

#!/बिन/बैश
#फ़ायरफ़ॉक्स चल रहा है
कार्यकारीफ़ायर्फ़ॉक्स


इसके अलावा, हम exec कमांड का उपयोग करके बैश से कोई भी प्रोग्राम चला सकते हैं।

6. कमांड-लाइन प्रोसेसिंग
कमांड-लाइन प्रोसेसिंग टर्मिनल पर दर्ज किए गए डेटा के प्रसंस्करण को संदर्भित करता है। कमांड-लाइन डेटा को कई उद्देश्यों के लिए संसाधित किया जाता है जैसे कि उपयोगकर्ता इनपुट पढ़ना, आदेशों को कम करना और तर्कों को पढ़ना। पहले, हमने रीड कमांड पर चर्चा की है। रीड कमांड का उपयोग कमांड-लाइन प्रोसेसिंग के लिए भी किया जाता है। इस खंड में, हम कमांड-लाइन तर्कों के प्रसंस्करण पर चर्चा करेंगे। बैश में, हम उन तर्कों को संसाधित कर सकते हैं जो टर्मिनल पर पारित या लिखे गए हैं। तर्कों को उसी तरह संसाधित किया जाता है जैसे वे पारित किए जाते हैं। इसलिए, इसे स्थितीय पैरामीटर कहा जाता है। अन्य प्रोग्रामिंग भाषाओं के विपरीत, बैश में तर्कों का अनुक्रमण 1 से शुरू होता है। डॉलर चिह्न ($) का उपयोग तर्कों को पढ़ने के लिए किया जाता है। उदाहरण के लिए, $1 पहला तर्क पढ़ता है, $2 दूसरा तर्क पढ़ता है, और इसी तरह। उपयोगकर्ता से इनपुट लेने जैसे विभिन्न कारणों से तर्कों को पार्स किया जा सकता है।

#!/बिन/बैश
फेंक दिया 'अपना नाम दर्ज करें'
#पहले तर्क को संसाधित करना
फेंक दिया 'पहला नाम:' $ 1
#दूसरा तर्क संसाधित करना
फेंक दिया 'मध्य नाम:'$ 2
#तीसरे तर्क को संसाधित करना
फेंक दिया 'उपनाम:' $3
फेंक दिया 'पूरा नाम:' $ 1 $ 2 $3


टर्मिनल से डेटा को रीड का उपयोग करके पढ़ना, और तर्कों को पार्स करना कमांड-लाइन प्रोसेसिंग के सबसे उपयुक्त उदाहरण हैं।

बैश का इतिहास और अन्य शैलों के साथ तुलना

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

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

निष्कर्ष

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