बैश सिद्धांत

0. सूचकांक

1. जो चीजें ज्यादातर लोगों के लिए होती हैं
2. एक स्क्रिप्ट की संरचना
3. स्क्रीन पर प्रिंट करें
4. उपयोगकर्ता INPUT पढ़ें
5. बैश में गणना
6. शर्तें
7. छोरों
8. कार्यों
9. गेटअप्स

1. ऐसी चीजें जो ज्यादातर लोगों के साथ होती हैं

/ बिन / बैश या / बिन / श

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

यूनिकोड बनाम एएससीआईआई

क्या आपने कभी सोचा है कि आप अपनी स्क्रिप्ट में "ever" या "ñ" का उपयोग क्यों नहीं कर सकते हैं? या लहजे का उपयोग करें? यह इंटरैक्टिव स्क्रिप्ट्स में काफी कष्टप्रद हो सकता है। ऐसा इसलिए है क्योंकि बैश का डिफ़ॉल्ट एन्कोडिंग ASCII है, या जो समान है, अंग्रेजी वर्ण सेट है। इसे बदलने के लिए, हमें केवल अपनी स्क्रिप्ट को बताना होगा कि हम यूनिकोड का उपयोग करना चाहते हैं। उसके लिए आपको कमांड दुभाषिया के ठीक बाद एक लाइन जोड़ना होगा:

# - * - ENCODING: UTF-8 - * -

सावधान रहें, यह महत्वपूर्ण है कि यह लाइन स्क्रिप्ट की शुरुआत में है।

स्क्रिप्ट को निष्पादन योग्य बनाएं

यह मजेदार है कि कितने लोग स्क्रिप्ट को «के साथ चलाते हैं$ बैश स्क्रिप्ट" के बजाय "$ ./cript.sh»आखिरकार, यही हमने एक खोल के लिए परिभाषित किया है।

निष्पादन अनुमतियाँ जोड़ने के लिए, आपको निष्पादित करना होगा:

sudo + x script.sh

BIN = "फ़ोल्डर जहां हमारे पास स्क्रिप्ट्स" PATH = "$ BIN $ PATH"

2. एक स्क्रिप्ट की संरचना

1. सिर
2. वैश्विक चर की परिभाषा
3. मदद
4. कार्यों
5. मुख्य भाग

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

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

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

समारोह में मदद () {प्रतिध्वनि "" हमारी अच्छी तरह से स्वरूपित मदद पाठ। "" अगर बाहर निकलें [[-z $ 1 || $ 1 == "-ह" || $ 1 == "--help"]]; तो फाई मदद करते हैं

यदि हम सहायता फ़ंक्शन में "बाहर निकलें" जोड़ते हैं, तो हम हर बार मदद से चलने वाली स्क्रिप्ट से बाहर निकलेंगे, उदाहरण के लिए त्रुटि संदेश, आदि। हम कोड की कुछ पंक्तियों को सहेजते हैं।

यह शर्त बताती है कि स्क्रीन स्क्रीन पर प्रदर्शित होने में मदद करती है और यदि स्क्रिप्ट बिना मापदंडों के चलती है या बाहर निकली है, तो -h / –help निर्दिष्ट है। यदि आप देखते हैं कि अधिकांश लिनक्स कार्यक्रमों का मानक व्यवहार है।

3. स्क्रीन पर प्रिंट करें

बैश में स्क्रीन प्रिंटिंग के लिए 2 मुख्य कमांड हैं: «गूंज»Y«printf«। वे दोनों बस के रूप में तेजी से कर रहे हैं और दोनों मार का हिस्सा हैं। एक शुरुआत के लिए मुख्य अंतर यह है कि गूंज अंत में एक नई रेखा जोड़ता है, जबकि «printf"नहीं करता।

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

यही कारण है कि मैं «printf«, जो मुझे सिरदर्द नहीं देता है और अधिक व्यवहार भी करता है जैसे«printf»C या« सेछाप»अजगर, यह बहुत महत्वपूर्ण है अगर आप कभी भी अपनी स्क्रिप्ट को किसी अन्य प्रोग्रामिंग भाषा में पोर्ट करना चाहते हैं।

4. उपयोगकर्ता INPUT पढ़ें

सब कुछ हम अपनी स्क्रिप्ट के नाम के बाद लिखते हैं और ENTER कुंजी मारने से पहले विशेष चर में स्वचालित रूप से सहेजा जाता है। ये चर $ X प्रकार के हैं जहाँ X एक संख्या है।

«$0»हमारी लिपि का नाम बताता है और« से$1»अनंत के लिए जो कुछ हमने लिखा है वह बाद में परिवर्तनशील है। उदाहरण के लिए:

बिल्ली << EOF >> test.sh #! / bin / bash # - * - ENCODING: UTF-8 - * - प्रिंटफ "\ $ 0 = $ 0 \ n" प्रिंटफ "\ $ 1 = $ 1 \ n" प्रिंटफ \ _ $ 2 = $ 2 \ n "EOF chmod + x script.sh//cript.sh मेरी file.txt

हम एक परीक्षण स्क्रिप्ट बनाते हैं, इसे निष्पादन योग्य बनाते हैं, और इसे 2 मापदंडों के साथ चलाते हैं। हम स्क्रीन आउटपुट प्राप्त करते हैं:

$ 0 = ./cript.sh $ 1 = मेरा $ 2 = file.txt

उद्धरणों का उपयोग करके हम "my file.txt" को "$ 1" में पास कर सकते हैं।

हम "रीड" कमांड के साथ एक उपयोगकर्ता के INPUT को भी पढ़ सकते हैं, सीधे उस वेरिएबल को इंगित करते हैं जहां हम पैरामीटर को सहेजना चाहते हैं। उदाहरण के लिए:

प्रिंटफ "आपका नाम क्या है? \ n" पढ़ें NAME प्रिंटफ "Hello, $ NAME। \ n"

5. बैश में गणना

उसके लिए हम «का उपयोग कर सकते हैंexpr«, जब तक हमें जटिल गणना करने की आवश्यकता नहीं है। दो बातों पर ध्यान दिया जाना चाहिए, पहला यह है कि «expr»केवल पूरी संख्या स्वीकार करता है, दूसरा यह है कि विभाजन पूरे परिणाम देता है, बाकी को देखने के लिए हम« का उपयोग कर सकते हैं%"।

आमतौर पर हम expr के परिणाम को एक चर में निर्दिष्ट करना चाहते हैं। हम दो तरीकों से कर सकते हैं:

VAR2 = `expr $ VAR1 / 10` VAR2 = $ (expr $ VAR1 / 100)

आप भी छोड़ सकते हैं «expr»डबल कोष्ठक का उपयोग करना:

VAR2 = $ (($ VAR1 / 100))

6। मामले

यह «के बारे में पहले से ही बहुत व्यापक तरीके से लिखा गया हैif" 'अन्य" 'elif»और शर्तें। आप इसके बारे में पढ़ सकते हैं:

• बाश में प्रोग्रामिंग: भाग 1
• बैश: यदि, फिर, और स्थितियां
• अगर एक फ़ाइल या फ़ोल्डर मौजूद है या नहीं और एक लूप के साथ जाँचें
• बाश में प्रोग्रामिंग: भाग 2

मैं बस सरल वर्ग कोष्ठक के उपयोग के बीच के अंतर को उजागर करना चाहता हूं, «[]«, और डबल कोष्ठक,«[[]]«, शर्तों के लिए। डबल ब्रैकेट के साथ हम अतिरिक्त स्थितियों का उपयोग कर सकते हैं:

• «&&"के लिए और
• «||»के लिए या

काम में लाना "&&»Y«||»साधारण वर्गाकार कोष्ठकों के साथ प्रत्येक भाग को अलग-अलग वर्गाकार कोष्ठकों के बीच अलग किया जाना चाहिए। स्क्रिप्ट के भाग के लिए उपयोग किया जाने वाला उदाहरण जो देखने में मदद करता है कि क्या चलाने की आवश्यकता है:

अगर [-z "$ 1"] || ["$ 1" == "-ह"] || ["$ 1" == "--हेल्प"]]; तो फाई मदद करते हैं

यह हमें त्रुटियों को रोकने के लिए उद्धरणों में परिवर्तनशील नाम लिखने से भी बचाता है। उदाहरण के लिए:

अगर [$ 1 = 1]; फिर प्रिंटफ "पैरामीटर 1 के बराबर है"; फाई अगर ["$ 1" = 1]; फिर प्रिंटफ "पैरामीटर 1 के बराबर है"; फाई अगर [[$ 1 = 1]]; फिर प्रिंटफ "पैरामीटर 1 के बराबर है"; फाई

यदि script.sh बिना किसी पैरामीटर के चलाया जाता है, तो पहला मामला एक त्रुटि देगा:

bash: [: =: unary ऑपरेटर अपेक्षित है

क्या चर्चा नहीं की गई है «मामला«, सरल बनाने के लिए इस्तेमाल किया«if«। चलिए शुरुआत करते हैं, जब हमारे पास कोई «if»सभी कोड निष्पादित किए जाएंगे। अगर हम एक शर्त जोड़ दें «if»हमारे पास दो मामले होंगे, एक कोड जिसमें ब्लॉक« के अंदर हैif»और दूसरा मामला जहां इस ब्लॉक को निष्पादित नहीं किया गया है।

यदि हम एक «अन्य«हमारे पास भी दो मामले होंगे, लेकिन ये दोनों मामले पिछले वाले से अलग हैं। क्योंकि अब दो सशर्त कोड ब्लॉक, A और B और एक C ब्लॉक होगा, जो कि बाकी प्रोग्राम है। A या B निष्पादित किया जाएगा, और C. पिछले मामले में यह A और C या केवल C था।

लेखन की स्थिति से बचने के लिए «यदि नहीं तो"भीतर"अन्य»और कोड को पढ़ने को आसान बनाने के लिए, इसे बनाया गया था«elif«। जब हमारे पास कई स्थितियां होती हैं जो पिछले एक पर निर्भर करती हैं, उदाहरण के लिए संख्याओं की श्रेणी या प्रकार:

VAR1 = $ 1 यदि [[$ VAR1 = 1]]; फिर प्रिंटफ "1 \ n" एलिफ [[$ VAR1 = 2]]; फिर प्रिंटफ "2 \ n" एलिफ [[$ VAR1 = 3]]; उसके बाद "3 \ n" और फिर प्रिंटफ़ "कोई नहीं \" फाई

पिछले «के मामले मेंelif»कई शर्तों को पढ़ा जाएगा। मामले के साथ यह प्रक्रिया सुव्यवस्थित है:

VAR1 = $ 1 मामला $ VAR 1 में) प्रिंटफ "1 \ n" ;; 2) प्रिंटफ "2 \ n" ;; 3 | 4) प्रिंटफ "3 या 4, यह निर्भर करता है \ n" ;; *) प्रिंटफ "कोई नहीं \ n" ;; वह सी

एक चर पढ़ा जाएगा, इस मामले में VAR1, और यह जांचा जाएगा कि क्या यह किसी भी मामले के बराबर है, यदि नहीं, तो डिफ़ॉल्ट मामला "*" निष्पादित किया जाएगा। डबल अर्धविराम «के बराबर हैंतोड़ना", वे बताते है"मामला»जिसे ​​समाप्त होना है।

7. लूप

किसी भी प्रोग्रामिंग भाषा में बहुत कम छोरों को जाना जाता है। बैश में वे «जब" 'जब तक»Y«एसटी «। इनके बारे में पहले ही ब्लॉग में लिखा जा चुका है:

• बाश में प्रोग्रामिंग: भाग 1
• बश में प्रोग्रामिंग: part2

दो प्रकार के लूप हैं «एसटी «, वे जो टाइप के हैं«LOQUESEA में VAR के लिए $»और टाइप C के क्या हैं«$ के लिए ((I = 0; मैं <= 10; I ++))«। दूसरे प्रकार के छोरों «एसटी »बहुत उपयोगी हैं, लूप की शुरुआत में इसके 3 भाग हैं:

• चर की घोषणा और दीक्षा (इस मामले में एक सहायक चर "I = 0")।
• निष्पादन की स्थिति (जब तक कि मैं 10 से कम या उसके बराबर न हो)।
• सहायक चर की वृद्धि

मेरी राय में यह सभी का सबसे शक्तिशाली लूप है। एक उदाहरण, जो 0 से 10 तक की सभी संख्याओं को सम्मिलित करता है, समावेशी:

#! / बिन / बैश के लिए ((I = 0; मैं <= 10; I ++)); प्रिंटफ "$ I \ n" किया

8. कार्य

कुछ चीजें हैं जो बैश हमें करने की अनुमति नहीं देती हैं, है ना? पहली नज़र में, बाश फ़ंक्शंस आपको 3 चीज़ें करने से रोकते हैं: फ़ंक्शंस में लोकल वैरिएबल घोषित करना, फ़ंक्शंस के लिए पैरामीटर पास करना और पैरामीटर वापस करना। हर चीज का एक हल होता है।

ऐसा कुछ न करें:

#! / बिन / बाश VAR = 1 प्रिंट "$ VAR \ n" फ़ंक्शन हैलो () {VAR = 2 प्रिंटफ "$ VAR \ n"} हैलो प्रिंट "$ VAR \ n"

यह स्क्रीन 1, 2 और 2 को प्रिंट करता है।

स्थानीय चर घोषित करने के लिए, «जोड़ेंस्थानीय»घोषणा करते समय:

"

यह स्क्रीन पर 1, 1, 2, 1 प्रिंट करता है।

आप किसी फ़ंक्शन के लिए पैरामीटर कैसे पास करते हैं?

# / / बिन / बाश # - * - ENCODING: UTF-8 - * - फ़ंक्शन हैलो () {प्रिंटफ "हैलो $ 1 \ n"}

प्रिंटफ "आपका नाम क्या है? \ n"
VAR1 पढ़ें
हैलो $ VAR1

कैसे लौटाए जाते हैं पैरामीटर?

# / / बिन / बाश # - * - ENCODING: UTF-8 - * - फंक्शन हेल्लो () {प्रिंटफ "हैलो होलीटा"} प्रिंटफ "आपका नाम क्या है? \ n" VAR1 VAR1 = $ (हेल्लो) # HERE IT IS? प्रिंटफ "$ VAR1 $ VAR2 \ n"

जैसा कि आप देख सकते हैं, इसमें दो कमियां हैं, आप केवल एक पैरामीटर वापस कर सकते हैं, जो एक वेक्टर this हो सकता है, और यदि आप एक पैरामीटर वापस करना चाहते हैं, तो आप उस फ़ंक्शन से स्क्रीन पर प्रिंट नहीं कर सकते।

9. गेट्स

जटिल स्क्रिप्ट बनाने के लिए बैश के बारे में जानने के लिए आखिरी चीजों में से एक है «गेट्स«। इसका उपयोग ऑर्डर की परवाह किए बिना स्क्रिप्ट में विकल्प पास करने के लिए किया जाता है। केवल नकारात्मक पक्ष यह है कि यह केवल छोटे विकल्पों को प्रभावित करता है:

# / / बिन / बाश # - * - ENCODING: UTF-8 - * - VARC = 0 फंक्शन हेल्प () {प्रिंटफ "मेसेज \ n" एक्जिट "अगर [[-ज़ $ 1]]; फिर गेटअप करते समय फाई की मदद करें: हा: बी: सी ऑप्ट; मामले में $ ऑप्ट करें) मदद ;; :) मदद ;; a) VARA = $ OPTARG ;; b) VARB = $ OPTARG ;; c) VARC = 1 ;; \?) मदद ;; esac किया # स्क्रिप्ट का मुख्य खंड जो VARA, VARB और VARC के साथ # चीजें करता है

«गेटअप्स»विकल्पों को एक-एक करके पढ़ता है, इसलिए एक लूप की आवश्यकता होती है।

दो प्रकार के विकल्प हैं जिनका उपयोग करके पास किया जा सकता है «गेटअप":

• पैरामीटर्स ने झंडे को बुलाया, इस मामले में -c या -h। वे उस पत्र के साथ निर्दिष्ट होते हैं जिसे हम उपयोग करना चाहते हैं। वे बूलियन चर की तरह हैं, «<strong>उद्देश्य</strong>»(हैं) या«असत्य"(वे यहाँ नहीं हैं)।
• संबद्ध तर्कों के साथ पैरामीटर, कुछ भी, -b कुछ भी। वे उस पत्र के साथ निर्दिष्ट हैं जिसे हम नीचे एक कॉलन के साथ चाहते हैं। तर्क OPTARG में संग्रहीत है (यह नाम अपरिवर्तनीय है)।

यह स्क्रिप्ट क्या करती है?

मदद संदेश तब प्रदर्शित करता है जब कोई विकल्प पारित नहीं होता है, जब "-एच" पैरामीटर पारित होता है, जब एक अवैध पैरामीटर पारित किया जाता है (उदाहरण के लिए "-x", यह "\" द्वारा किया जाता है) या जब एक कोई तर्क (":") के साथ मान्य पैरामीटर। बाकी मामलों में यह VARC में 1 के रूप में "-c" की उपस्थिति को बचाता है, और VARA और VARB में "-a" और "-b" के साथ पारित मान।