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

लिनक्स और मैक सिस्टम प्रशासक आमतौर पर टर्मिनल के माध्यम से स्क्रिप्टिंग से परिचित होते हैं, लेकिन यहां तक ​​कि विंडोज उपयोगकर्ता भी कर सकते हैं लिनक्स के लिए विंडोज सबसिस्टम के साथ कार्रवाई पर जाएं.

विंडोज 10 पर लिनक्स बैश शैल कैसे प्राप्त करें

एक अलग पीसी पर स्विच करने के लिए या वीएम चलाने के लिए लिनक्स का उपयोग करने की आवश्यकता नहीं है? इसके बजाय बश शेल टर्मिनल के साथ विंडोज 10 में लिनक्स चलाएं!

कैसे बाश लिपियों काम करते हैं

बैश स्क्रिप्ट बस एक सादा पाठ फ़ाइल है जिसमें कमांड की एक श्रृंखला होती है जिसे बैश शेल पढ़ और निष्पादित कर सकता है। बैश पूर्व-कैटालिना मैकओएस में डिफ़ॉल्ट शेल है, और अधिकांश लिनक्स वितरण।

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

instagram viewer

सबसे पहले, एक सुविधाजनक स्थान पर निम्न फ़ाइल बनाएं (आदर्श रूप से, एक टर्मिनल खोलें और पहले वांछित निर्देशिका में नेविगेट करें):

#! / बिन / बैश
इको "हैलो, वर्ल्ड"

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

$ chmod + x hello_world.sh
$ ./hello_world.sh

चामोद पहली पंक्ति पर कमांड फ़ाइल को निष्पादन योग्य बनाता है, जिसका अर्थ है कि यह अपना नाम लिखकर चलाया जा सकता है, जैसा कि दूसरी पंक्ति में है।

यदि आप "हैलो, वर्ल्ड" शब्दों को अपने टर्मिनल में एक लाइन पर प्रिंट करते हुए देखते हैं, तो आवश्यक रूप से सब कुछ काम कर रहा है।

कैसे काम करता है लूप्स के लिए

सामान्य प्रोग्रामिंग में, लूप के लिए दो मुख्य प्रकार हैं: संख्यात्मक तथा प्रत्येक के लिए. संख्यात्मक प्रकार पारंपरिक रूप से सबसे आम है, लेकिन उपयोग में, यह आमतौर पर दूसरा तरीका है।

लूप के लिए संख्यात्मक आमतौर पर एक पूर्णांक पर ध्यान केंद्रित करते हैं जो यह निर्धारित करता है कि कितने पुनरावृत्तियों को किया जाएगा, उदाहरण के लिए:

के लिए (i = 0); i <100; i ++) {
/ * बार-बार निष्पादित करने के बयान * /
}

यह लूप के लिए एक परिचित-खोज है जो 100 बार ठीक होगा, जब तक कि मैं लूप के भीतर बदल नहीं जाता, या किसी अन्य कथन के कारण लूप को रोक दिया जाता है।

Foreach छोरों, इसके विपरीत, सूची या सरणियों जैसे संरचनाओं पर काम करते हैं, और उस संग्रह के भीतर प्रत्येक आइटम के लिए पुनरावृति करते हैं:

लोग = ["पीटर", "पॉल", "मैरी"]
foreach (व्यक्ति के रूप में लोग) {
अगर (व्यक्ति == "पॉल") {
...
}
}

कुछ भाषाएं थोड़ा अलग वाक्यविन्यास का उपयोग करती हैं जो संग्रह और आइटम के क्रम को स्वैप करता है:

लोग = ["पीटर", "पॉल", "मैरी"]
के लिए (लोगों में व्यक्ति) {
अगर (व्यक्ति == "पॉल") {
...
}
}

लूप्स के लिए

बैश में, फ़ॉरच-या अंदर के लिए—लूप आम है। मूल वाक्यविन्यास है, बस:

[सूची] में arg के लिए
करना
/ * बार-बार निष्पादित करने के बयान * /
/ * arg का मूल्य $ arg * / का उपयोग करके प्राप्त किया जा सकता है
किया हुआ

उदाहरण के लिए, तीन स्पष्ट रूप से नामित फ़ाइलों के माध्यम से पुनरावृति करने के लिए:

एक। में दो फ़ाइल के लिए। तीन
करना
ls "$ फ़ाइल"
किया हुआ

यदि ऐसी फाइलें वर्तमान निर्देशिका में मौजूद हैं, तो इस स्क्रिप्ट से आउटपुट निम्न होगा:

एक
दो
तीन .सी

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

* .xml में फ़ाइल के लिए
करना
ls -l "$ फ़ाइल"
किया हुआ

यहाँ कुछ उदाहरण आउटपुट है:

$ -rw-r - r-- 1 बॉबी स्टाफ 2436 3 Nov 2019 feed.xml
$ -rw-r - r-- 1 बॉबी स्टाफ 6447 27 अक्टूबर 16:24 sitemap.xml

ऐसा करने का एक लंबा-चौड़ा तरीका बहुत पसंद आ सकता है:

$ ls -l * .xml

लेकिन एक महत्वपूर्ण अंतर है: लूप के लिए निष्पादन रास कार्यक्रम 2 अलग-अलग समय, एक एकल फ़ाइलनाम के साथ इसे हर बार पास किया गया। अलग-अलग ls उदाहरण में, ग्लोब पैटर्न (* .xml) पहले फ़ाइल नाम से मेल खाता है और फिर उन सभी को व्यक्तिगत कमांड-लाइन मापदंडों के रूप में एक उदाहरण के लिए भेजता है। रास.

यहाँ एक उदाहरण है जो इसका उपयोग करता है स्वागत (शब्द गणना) अंतर को और अधिक स्पष्ट करने के लिए कार्यक्रम:

$ wc -l * .xml
44 फीड.एक्सएमएल
231 साइटमैप। Xml
275 कुल

स्वागत कार्यक्रम प्रत्येक फ़ाइल में लाइनों की संख्या को अलग-अलग गिनता है, फिर उन सभी में कुल गणना प्रिंट करता है। इसके विपरीत, यदि स्वागत लूप के लिए संचालित होता है:

* .xml में फ़ाइल के लिए
करना
wc -l $ फ़ाइल
किया हुआ

आप अभी भी प्रत्येक फ़ाइल की गणना देखेंगे:

44 फीड.एक्सएमएल
231 साइटमैप। Xml

लेकिन कुल मिलाकर कुल सारांश नहीं है क्योंकि स्वागत अलगाव में चलाया जाता है, हर बार लूप पुनरावृत्त होता है।

जब एक सूची एक सूची नहीं है

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

एक। में दो फ़ाइल के लिए

इस तरह नहीं:

"one.c दो.c" में फ़ाइल के लिए

दूसरा उदाहरण डबल-कोट्स में फाइलनेम को जोड़ता है जिसके परिणामस्वरूप सूची में सिर्फ एक ही पैरामीटर होता है; लूप के लिए केवल एक समय निष्पादित करेगा। ऐसे मामलों में एक चर का उपयोग करके इस समस्या से बचा जा सकता है:

फ़ाइलें = "one.c दो.c"
$ FILES में फ़ाइल के लिए
करना
...
किया हुआ

ध्यान दें कि चर घोषणा को दोहरे मानों में अपने मूल्य को सम्मिलित करने की आवश्यकता है!

बिना किसी सूची के

के माध्यम से पुनरावृति करने के लिए कुछ भी नहीं के साथ, एक लूप के लिए जो भी कमांड-लाइन तर्क स्क्रिप्ट को प्रदान किए जाने पर संचालित होता है। उदाहरण के लिए, यदि आपके पास एक स्क्रिप्ट नाम है args.sh निम्नलिखित शामिल हैं:

#! / बिन / श
एक के लिए
करना
गूंज $ ए
किया हुआ

फिर args.sh निष्पादित करने से आपको निम्नलिखित जानकारी मिलेगी:

$ ./args.sh एक दो तीन
एक
दो
तीन

बैश इस मामले को पहचानता है और व्यवहार करता है एक काम के लिए के बराबर है के लिए $ @ करते हैं जहाँ $ @ कमांड-लाइन तर्कों का प्रतिनिधित्व करने वाला एक विशेष चर है।

लूप के लिए एक पारंपरिक न्यूमेरिक का अनुकरण

बैश स्क्रिप्ट अक्सर फाइलों की सूची या अन्य कमांड से आउटपुट की लाइनों के साथ सौदा करते हैं, इसलिए लूप के प्रकार के लिए सामान्य है। हालांकि, पारंपरिक सी-स्टाइल ऑपरेशन अभी भी समर्थित है:

के लिए (i = 1); i <= 5; i ++))
करना
इको $ i
किया हुआ

यह क्लासिक रूप है जिसमें तीन भाग हैं:

  1. जब पहली बार लूप का सामना किया जाता है तो एक वैरिएबल इनिशियलाइज़ किया जाता है (i = 1)
  2. लूप तब तक जारी रहता है जब तक कि स्थिति (i <= 5) सही न हो
  3. हर बार लूप के चारों ओर, परिवर्तनशील वृद्धि होती है (i ++)

दो मूल्यों के बीच फेरबदल एक सामान्य पर्याप्त आवश्यकता है जो एक छोटा, थोड़ा कम भ्रमित विकल्प है:

i में {1..5} के लिए
करना
इको $ i
किया हुआ

ब्रेस विस्तार जो प्रभावी रूप से होता है, उपरोक्त को लूप में बदल देता है:

मैं 1 2 3 4 में

ब्रेक और जारी रखने के साथ महीन पाश नियंत्रण

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

#! / बिन / बैश
* में फ़ाइल के लिए
करना
अगर [! -f "$ फ़ाइल"]
तब फिर
गूंज "$ फ़ाइल एक फ़ाइल नहीं है"
जारी रखें
फाई
num_chars = $ (wc -c इको $ फ़ाइल "$ num_chars वर्ण लंबा" है
अगर [$ num_chars -gt 100]
तब फिर
इको "मिली $ फ़ाइल"
टूटना
फाई
किया हुआ

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

निष्कर्ष

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

ईमेल
Apple के ऐप गोपनीयता लेबल पूरी तरह से सटीक नहीं हो सकते हैं

रिपोर्ट बताती है कि ऐपल के ऐप प्राइवेसी लेबल में कुछ समस्याएं हो सकती हैं।

संबंधित विषय
  • प्रोग्रामिंग
  • लिनक्स
लेखक के बारे में
बॉबी जैक (19 लेख प्रकाशित)

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

बॉबी जैक से अधिक

हमारे न्यूज़लेटर की सदस्यता लें

टेक टिप्स, रिव्यू, फ्री ईबुक और एक्सक्लूसिव डील्स के लिए हमारे न्यूज़लेटर से जुड़ें!

एक और कदम…!

कृपया हमें आपके द्वारा भेजे गए ईमेल में अपने ईमेल पते की पुष्टि करें।

.