बैश प्रोग्रामिंग में महारत हासिल करें: लॉजिकल ऑपरेटर्स और शेल एक्सपैंशन समझाए गए

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

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

लॉजिकल ऑपरेटर्स किसी प्रोग्राम में निर्णय लेने और उन निर्णयों के आधार पर निर्देशों के विभिन्न सेट को निष्पादित करने का आधार हैं। इसे कभी-कभी फ्लो कंट्रोल कहा जाता है।

लॉजिकल ऑपरेटर्स

बैश में लॉजिकल ऑपरेटर्स का एक बड़ा सेट होता है जिनका उपयोग कंडीशनल एक्सप्रेशन में किया जा सकता है। if कंट्रोल स्ट्रक्चर का सबसे बुनियादी रूप एक कंडीशन का परीक्षण करता है और फिर यदि कंडीशन सत्य है तो प्रोग्राम स्टेटमेंट्स की एक सूची को निष्पादित करता है। ऑपरेटर्स के तीन प्रकार हैं: फाइल, न्यूमेरिक, और नॉन-न्यूमेरिक ऑपरेटर्स। प्रत्येक ऑपरेटर सत्य (0) लौटाता है यदि कंडीशन पूरी होती है और असत्य (1) यदि कंडीशन पूरी नहीं होती।

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

if [ arg1 operator arg2 ] ; then list
 or
 if [ arg1 operator arg2 ] ; then list ; else list ; fi

तुलना में स्पेस आवश्यक हैं जैसा दिखाया गया है। सिंगल स्क्वायर ब्रेसेस, [ और ], पारंपरिक बैश सिंबल हैं जो test कमांड के समकक्ष हैं:

if test arg1 operator arg2 ; then list

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

if [[ arg1 operator arg2 ]] ; then list

फाइल ऑपरेटर्स

फाइल ऑपरेटर्स बैश के भीतर लॉजिकल ऑपरेटर्स का एक शक्तिशाली सेट हैं। चित्र 1 में 20 से अधिक विभिन्न ऑपरेटर्स सूचीबद्ध हैं जो बैश फाइलों पर कर सकता है। मैं इनका उपयोग अपनी स्क्रिप्ट्स में काफी बार करता हूँ।

चित्र 1: बैश फाइल ऑपरेटर्स

उदाहरण के तौर पर, एक फाइल के अस्तित्व का परीक्षण करके शुरू करें:

[student@studentvm1 testdir]$ File="TestFile1" ; if [ -e $File ] ; then echo "The file $File exists." ; else echo "The file $File does not exist." ; fi
 The file TestFile1 does not exist.
 [student@studentvm1 testdir]$

अब, टेस्टिंग के लिए TestFile1 नाम की एक फाइल बनाएं। फिलहाल, इसमें कोई डेटा होना आवश्यक नहीं है:

[student@studentvm1 testdir]$ touch TestFile1

इस छोटे CLI प्रोग्राम में फाइल नाम के लिए टेक्स्ट स्ट्रिंग के बजाय $File वेरिएबल का मान बदलना आसान है:

[student@studentvm1 testdir]$ File="TestFile1" ; if [ -e $File ] ; then echo "The file $File exists." ; else echo "The file $File does not exist." ; fi
 The file TestFile1 exists.
 [student@studentvm1 testdir]$

अब, यह निर्धारित करने के लिए एक टेस्ट चलाएं कि क्या कोई फाइल मौजूद है और उसकी लंबाई शून्येतर है, जिसका अर्थ है कि उसमें डेटा है। आप तीन कंडीशन्स का परीक्षण करना चाहते हैं: 1. फाइल मौजूद नहीं है; 2. फाइल मौजूद है और खाली है; और 3. फाइल मौजूद है और इसमें डेटा है। इसलिए, आपको टेस्ट्स का एक अधिक जटिल सेट चाहिए—सभी कंडीशन्स का परीक्षण करने के लिए if-elif-else कंस्ट्रक्ट में elif स्टैंजा का उपयोग करें:

[student@studentvm1 testdir]$ File="TestFile1" ; if [ -s $File ] ; then echo "$File exists and contains data." ; fi
 [student@studentvm1 testdir]$

इस मामले में, फाइल मौजूद है लेकिन इसमें कोई डेटा नहीं है। कुछ डेटा जोड़ें और फिर से प्रयास करें:

[student@studentvm1 testdir]$ File="TestFile1" ; echo "This is file $File" > $File ; if [ -s $File ] ; then echo "$File exists and contains data." ; fi
 TestFile1 exists and contains data.
 [student@studentvm1 testdir]$

यह काम करता है, लेकिन यह तीन संभावित कंडीशन्स में से केवल एक विशिष्ट कंडीशन के लिए वास्तव में सटीक है। एक else स्टैंजा जोड़ें ताकि आप कुछ अधिक सटीक हो सकें, और फाइल को डिलीट करें ताकि आप इस नए कोड का पूरी तरह से परीक्षण कर सकें:

[student@studentvm1 testdir]$ File="TestFile1" ; rm $File ; if [ -s $File ] ; then echo "$File exists and contains data." ; else echo "$File does not exist or is empty." ; fi
 TestFile1 does not exist or is empty.

अब टेस्ट करने के लिए एक खाली फाइल बनाएं:

[student@studentvm1 testdir]$ File="TestFile1" ; touch $File ; if [ -s $File ] ; then echo "$File exists and contains data." ; else echo "$File does not exist or is empty." ; fi
 TestFile1 does not exist or is empty.

फाइल में कुछ कंटेंट जोड़ें और फिर से टेस्ट करें:

[student@studentvm1 testdir]$ File="TestFile1" ; echo "This is file $File" > $File ; if [ -s $File ] ; then echo "$File exists and contains data." ; else echo "$File does not exist or is empty." ; fi
 TestFile1 exists and contains data.

अब, एक फाइल जो मौजूद नहीं है और एक जो खाली है, के बीच भेद करने के लिए elif स्टैंजा जोड़ें:

[student@studentvm1 testdir]$ File="TestFile1" ; touch $File ; if [ -s $File ] ; then echo "$File exists and contains data." ; elif [ -e $File ] ; then echo "$File exists and is empty." ; else echo "$File does not exist." ; fi
 TestFile1 exists and is empty.
 [student@studentvm1 testdir]$ File="TestFile1" ; echo "This is $File" > $File ; if [ -s $File ] ; then echo "$File exists and contains data." ; elif [ -e $File ] ; then echo "$File exists and is empty." ; else echo "$File does not exist." ; fi
 TestFile1 exists and contains data.
 [student@studentvm1 testdir]$

अब आपके पास एक बैश CLI प्रोग्राम है जो इन तीन अलग-अलग कंडीशन्स का परीक्षण कर सकता है... लेकिन संभावनाएं अनंत हैं।

यदि आप प्रोग्राम स्टेटमेंट्स को इस तरह व्यवस्थित करते हैं जैसे आप उन्हें एक स्क्रिप्ट में करेंगे जिसे फाइल में सेव किया जा सकता है, तो अधिक जटिल कम्पाउंड कमांड्स की लॉजिक स्ट्रक्चर को देखना आसान होता है। चित्र 2 दिखाता है कि यह कैसा दिखेगा। if-elif-else स्ट्रक्चर के प्रत्येक स्टैंजा में प्रोग्राम स्टेटमेंट्स के इंडेंटेशन लॉजिक को स्पष्ट करने में मदद करते हैं।

File="TestFile1"
 echo "This is $File" > $File
 if [ -s $File ]
 then
 echo "$File exists and contains data." 
 elif [ -e $File ]
 then 
 echo "$File exists and is empty."
 else 
 echo "$File does not exist."
 fi

चित्र 2: कमांड लाइन प्रोग्राम को स्क्रिप्ट में जैसे दिखाई देगा वैसा पुनः लिखित

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

स्ट्रिंग तुलना ऑपरेटर्स

स्ट्रिंग तुलना ऑपरेटर्स अल्फ़ान्यूमेरिक कैरेक्टर्स की स्ट्रिंग्स की तुलना को सक्षम करते हैं। इन ऑपरेटर्स में से केवल कुछ ही हैं, जो चित्र 3 में सूचीबद्ध हैं।

चित्र 3: बैश स्ट्रिंग लॉजिकल ऑपरेटर्स

पहले, स्ट्रिंग लंबाई को देखें। तुलना में $MyVar के चारों ओर कोट्स होने चाहिए ताकि तुलना काम करे। (आपको अभी भी ~/testdir में काम करना चाहिए।)

[student@studentvm1 testdir]$ MyVar="" ; if [ -z "" ] ; then echo "MyVar is zero length." ; else echo "MyVar contains data" ; fi
 MyVar is zero length.
 [student@studentvm1 testdir]$ MyVar="Random text" ; if [ -z "" ] ; then echo "MyVar is zero length." ; else echo "MyVar contains data" ; fi
 MyVar is zero length.

आप इसे इस तरह भी कर सकते हैं:

[student@studentvm1 testdir]$ MyVar="Random text" ; if [ -n "$MyVar" ] ; then echo "MyVar contains data." ; else echo "MyVar is zero length" ; fi
 MyVar contains data.
 [student@studentvm1 testdir]$ MyVar="" ; if [ -n "$MyVar" ] ; then echo "MyVar contains data." ; else echo "MyVar is zero length" ; fi
 MyVar is zero length

कभी-कभी आपको किसी स्ट्रिंग की सटीक लंबाई जानने की आवश्यकता हो सकती है। यह तुलना नहीं है, लेकिन यह संबंधित है। दुर्भाग्य से, स्ट्रिंग की लंबाई निर्धारित करने का कोई सरल तरीका नहीं है। इसे करने के कुछ तरीके हैं, लेकिन मुझे लगता है कि expr (एक्सप्रेशन मूल्यांकन) कमांड का उपयोग करना सबसे आसान है। expr के मैन पेज को पढ़ें कि यह और क्या कर सकता है। ध्यान दें कि आप जिस स्ट्रिंग या वेरिएबल का परीक्षण कर रहे हैं उसके चारों ओर कोट्स आवश्यक हैं।

[student@studentvm1 testdir]$ MyVar="" ; expr length "$MyVar"
 0
 [student@studentvm1 testdir]$ MyVar="How long is this?" ; expr length "$MyVar"
 17
 [student@studentvm1 testdir]$ expr length "We can also find the length of a literal string as well as a variable."
 70

तुलना ऑपरेटर्स के संबंध में, मैं अपनी स्क्रिप्ट्स में यह निर्धारित करने के लिए बहुत सारे टेस्टिंग का उपयोग करता हूँ कि क्या दो स्ट्रिंग्स समान हैं (यानी, आइडेंटिकल)। मैं इस तुलना ऑपरेटर के नॉन-POSIX संस्करण का उपयोग करता हूँ:

[student@studentvm1 testdir]$ Var1="Hello World" ; Var2="Hello World" ; if [ "$Var1" == "$Var2" ] ; then echo "Var1 matches Var2" ; else echo "Var1 and Var2 do not match." ; fi
 Var1 matches Var2
 [student@studentvm1 testdir]$ Var1="Hello World" ; Var2="Hello world" ; if [ "$Var1" == "$Var2" ] ; then echo "Var1 matches Var2" ; else echo "Var1 and Var2 do not match." ; fi
 Var1 and Var2 do not match.

इन ऑपरेटर्स को आज़माने के लिए स्वयं कुछ और प्रयोग करें।

न्यूमेरिक तुलना ऑपरेटर्स

न्यूमेरिक ऑपरेटर्स दो न्यूमेरिक आर्गुमेंट्स के बीच तुलना करते हैं। अन्य ऑपरेटर क्लासेज की तरह, अधिकांश समझने में आसान हैं।

चित्र 4: बैश न्यूमेरिक तुलना लॉजिकल ऑपरेटर्स

यहाँ कुछ सरल उदाहरण हैं। पहला उदाहरण वेरिएबल $X को 1 पर सेट करता है, फिर जांचता है कि क्या $X 1 के बराबर है। दूसरे उदाहरण में, X को 0 पर सेट किया जाता है, इसलिए तुलना सत्य नहीं है।

[student@studentvm1 testdir]$ X=1 ; if [ $X -eq 1 ] ; then echo "X equals 1" ; else echo "X does not equal 1" ; fi
 X equals 1
 [student@studentvm1 testdir]$ X=0 ; if [ $X -eq 1 ] ; then echo "X equals 1" ; else echo "X does not equal 1" ; fi
 X does not equal 1
 [student@studentvm1 testdir]$

स्वयं कुछ और प्रयोग आज़माएं।

विविध ऑपरेटर्स

ये विविध ऑपरेटर्स दर्शाते हैं कि क्या कोई शेल ऑप्शन सेट है या किसी शेल वेरिएबल का कोई मान है, लेकिन यह वेरिएबल के मान का पता नहीं लगाता, केवल यह कि उसके पास एक है।

चित्र 5: विविध बैश लॉजिकल ऑपरेटर्स

इन ऑपरेटर्स को आज़माने के लिए स्वयं प्रयोग करें।

एक्सपैंशन (विस्तार)

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

ब्रेस एक्सपैंशन

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

पहले, यहाँ दिखाया गया है कि ब्रेस एक्सपैंशन क्या करता है:

[student@studentvm1 testdir]$ echo {string1,string2,string3}
 string1 string2 string3

खैर, यह बहुत मददगार नहीं है, है ना? लेकिन देखें कि जब आप इसे थोड़ा अलग तरीके से उपयोग करते हैं तो क्या होता है:

[student@studentvm1 testdir]$ echo "Hello "{David,Jen,Rikki,Jason}.
 Hello David. Hello Jen. Hello Rikki. Hello Jason.

यह कुछ उपयोगी लगता है—यह काफी टाइपिंग बचा सकता है। अब इसे आज़माएं:

[student@studentvm1 testdir]$ echo b{ed,olt,ar}s
 beds bolts bars

मैं आगे बढ़ सकता हूँ, लेकिन आपको विचार आ गया होगा।

टिल्ड एक्सपैंशन

यकीनन, सबसे आम एक्सपैंशन टिल्ड (~) एक्सपैंशन है। जब आप इसे cd ~/Documents जैसी कमांड में उपयोग करते हैं, तो बैश शेल इसे यूजर के पूर्ण होम डायरेक्टरी के शॉर्टकट के रूप में विस्तारित करता है।

टिल्ड एक्सपैंशन के प्रभावों को देखने के लिए इन बैश प्रोग्राम्स का उपयोग करें:

[student@studentvm1 testdir]$ echo ~
 /home/student
 [student@studentvm1 testdir]$ echo ~/Documents
 /home/student/Documents
 [student@studentvm1 testdir]$ Var1=~/Documents ; echo $Var1 ; cd $Var1
 /home/student/Documents
 [student@studentvm1 Documents]$

पाथनेम एक्सपैंशन

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

• ? — स्ट्रिंग के भीतर निर्दिष्ट स्थान पर किसी भी कैरेक्टर में से केवल एक से मेल खाता है
• * — स्ट्रिंग के भीतर निर्दिष्ट स्थान पर किसी भी कैरेक्टर में से शून्य या अधिक से मेल खाता है

यह एक्सपैंशन मिलान करने वाले डायरेक्टरी नामों पर लागू होता है। यह देखने के लिए कि यह कैसे काम करता है, सुनिश्चित करें कि testdir प्रेजेंट वर्किंग डायरेक्टरी (PWD) है और एक सादे लिस्टिंग से शुरू करें (मेरे होम डायरेक्टरी की सामग्री आपकी से अलग होगी):

[student@studentvm1 testdir]$ ls 
 chapter6 cpuHog.dos dmesg1.txt Documents Music softlink1 testdir6 Videos
 chapter7 cpuHog.Linux dmesg2.txt Downloads Pictures Templates testdir
 testdir cpuHog.mac dmesg3.txt file005 Public testdir tmp
 cpuHog Desktop dmesg.txt link3 random.txt testdir1 umask.test
 [student@studentvm1 testdir]$

अब उन डायरेक्टरीज को सूचीबद्ध करें जो Do, testdir/Documents, और testdir/Downloads से शुरू होती हैं:

Documents:
 Directory01 file07 file15 test02 test10 test20 testfile13 TextFiles
 Directory02 file08 file16 test03 test11 testfile01 testfile14
 file01 file09 file17 test04 test12 testfile04 testfile15
 file02 file10 file18 test05 test13 testfile05 testfile16
 file03 file11 file19 test06 test14 testfile09 testfile17
 file04 file12 file20 test07 test15 testfile10 testfile18
 file05 file13 Student1.txt test08 test16 testfile11 testfile19
 file06 file14 test01 test09 test18 testfile12 testfile20
 
 Downloads:
 [student@studentvm1 testdir]$

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

[student@studentvm1 testdir]$ ls -d Do*
 Documents Downloads
 [student@studentvm1 testdir]$

दोनों मामलों में, बैश शेल Do* पैटर्न को उन दो डायरेक्टरीज के नामों में विस्तारित करता है जो पैटर्न से मेल खाते हैं। लेकिन क्या होगा यदि पैटर्न से मेल खाने वाली फाइलें भी हैं?

[student@studentvm1 testdir]$ touch Downtown ; ls -d Do*
 Documents Downloads Downtown
 [student@studentvm1 testdir]$

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

कमांड सब्स्टीट्यूशन

कमांड सब्स्टीट्यूशन एक्सपैंशन का एक रूप है जो एक कमांड के STDOUT डेटा स्ट्रीम को दूसरे कमांड के आर्गुमेंट के रूप में उपयोग करने की अनुमति देता है; उदाहरण के लिए, एक लूप में प्रोसेस की जाने वाली वस्तुओं की सूची के रूप में। बैश मैन पेज कहता है: "कमांड सब्स्टीट्यूशन एक कमांड के आउटपुट को कमांड नाम से बदलने की अनुमति देता है।" मुझे यह सटीक लगता है, भले ही थोड़ा अस्पष्ट हो।

इस सब्स्टीट्यूशन के दो रूप हैं, `command` और $(command)। बैक टिक्स (`) का उपयोग करने वाले पुराने रूप में, कमांड में बैकस्लैश (\) का उपयोग इसके शाब्दिक अर्थ को बरकरार रखता है। हालांकि, जब नए पैरेंथेटिकल रूप में उपयोग किया जाता है, तो बैकस्लैश एक स्पेशल कैरेक्टर के रूप में अपना अर्थ ले लेता है। यह भी ध्यान दें कि पैरेंथेटिकल रूप कमांड स्टेटमेंट को खोलने और बंद करने के लिए केवल सिंगल पैरेंथेसिस का उपयोग करता है।

मैं अक्सर इस क्षमता का उपयोग कमांड-लाइन प्रोग्राम्स और स्क्रिप्ट्स में करता हूँ जहां एक कमांड के परिणामों को दूसरे कमांड के लिए आर्गुमेंट के रूप में उपयोग किया जा सकता है।

एक बहुत सरल उदाहरण से शुरू करें जो इस एक्सपैंशन के दोनों रूपों का उपयोग करता है (फिर से, सुनिश्चित करें कि testdir PWD है):

[student@studentvm1 testdir]$ echo "Todays date is `date`"
 Todays date is Sun Apr 7 14:42:46 EDT 2019
 [student@studentvm1 testdir]$ echo "Todays date is $(date)"
 Todays date is Sun Apr 7 14:42:59 EDT 2019
 [student@studentvm1 testdir]$

seq यूटिलिटी का -w ऑप्शन जनरेट की गई संख्याओं में लीडिंग जीरोज जोड़ता है ताकि वे सभी समान चौड़ाई की हों, यानी वैल्यू की परवाह किए बिना अंकों की समान संख्या। इससे उन्हें न्यूमेरिक सीक्वेंस में सॉर्ट करना आसान हो जाता है।

seq यूटिलिटी का उपयोग संख्याओं का एक क्रम उत्पन्न करने के लिए किया जाता है:

[student@studentvm1 testdir]$ seq 5
 1
 2
 3
 4
 5
 [student@studentvm1 testdir]$ echo `seq 5`
 1 2 3 4 5
 [student@studentvm1 testdir]$

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

[student@studentvm1 testdir]$ for I in $(seq -w 5000) ; do touch file-$I ; done

इस उपयोग में, स्टेटमेंट seq -w 5000 एक से 5,000 तक की संख्याओं की एक सूची उत्पन्न करता है। for स्टेटमेंट के भाग के रूप में कमांड सब्स्टीट्यूशन का उपयोग करके, संख्याओं की सूची का उपयोग for स्टेटमेंट द्वारा फाइल नामों के न्यूमेरिक भाग को उत्पन्न करने के लिए किया जाता है।

अंकगणितीय एक्सपैंशन

बैश पूर्णांक गणित कर सकता है, लेकिन यह थोड़ा बोझिल है (जैसा कि आप जल्द ही देखेंगे)। अंकगणितीय एक्सपैंशन का सिंटैक्स $((arithmetic-expression)) है, जो एक्सप्रेशन को खोलने और बंद करने के लिए डबल पैरेंथेसिस का उपयोग करता है।

अंकगणितीय एक्सपैंशन शेल प्रोग्राम या स्क्रिप्ट में कमांड सब्स्टीट्यूशन की तरह काम करता है; एक्सप्रेशन से गणना किया गया मान आगे के मूल्यांकन के लिए शेल द्वारा एक्सप्रेशन को बदल देता है।

एक बार फिर, कुछ सरल से शुरू करें:

[student@studentvm1 testdir]$ echo $((1+1))
 2
 [student@studentvm1 testdir]$ Var1=5 ; Var2=7 ; Var3=$((Var1*Var2)) ; echo "Var 3 = $Var3"
 Var 3 = 35

निम्नलिखित विभाजन का परिणाम शून्य होता है क्योंकि परिणाम एक से कम दशमलव मान होगा:

[student@studentvm1 testdir]$ Var1=5 ; Var2=7 ; Var3=$((Var1/Var2)) ; echo "Var 3 = $Var3"
 Var 3 = 0

यहाँ एक सरल गणना है जिसे मैं अक्सर स्क्रिप्ट या CLI प्रोग्राम में करता हूँ जो मुझे बताती है कि लिनक्स होस्ट में कुल कितनी वर्चुअल मेमोरी है। free कमांड वह डेटा प्रदान नहीं करता:

[student@studentvm1 testdir]$ RAM=`free | grep ^Mem | awk '{print $2}'` ; Swap=`free | grep ^Swap | awk '{print $2}'` ; echo "RAM = $RAM and Swap = $Swap" ; echo "Total Virtual memory is $((RAM+Swap))" ;
 RAM = 4037080 and Swap = 6291452
 Total Virtual memory is 10328532

मैंने कमांड सब्स्टीट्यूशन के लिए उपयोग किए जाने वाले कोड के खंडों को सीमांकित करने के लिए ` कैरेक्टर का उपयोग किया।

मैं बैश अंकगणितीय एक्सपैंशन का उपयोग ज्यादातर स्क्रिप्ट में सिस्टम रिसोर्स मात्रा की जांच करने और फिर परिणाम के आधार पर प्रोग्राम एक्ज़ीक्यूशन पथ चुनने के लिए करता हूँ।

सारांश

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

इस श्रृंखला का तीसरा लेख विभिन्न प्रकार के पुनरावृत्त संचालन करने के लिए लूप्स के उपयोग का पता लगाएगा।