हम ऐरे की अवधारणा के बिना एक प्रोग्रामिंग भाषा की कल्पना नहीं कर सकते। इससे कोई फर्क नहीं पड़ता कि विभिन्न भाषाओं में उन्हें कैसे लागू किया जाता है। इसके बजाय ऐरे हमें समान या अलग डेटा को एक प्रतीकात्मक नाम के तहत समेकित करने में मदद करते हैं।
चूंकि हम शेल स्क्रिप्टिंग से संबंधित हैं, यह लेख आपको कुछ शेल स्क्रिप्ट्स के साथ खेलने में मदद करेगा जो ऐरे की इस अवधारणा का उपयोग करते हैं।
ऐरे इनिशियलाइज़ेशन और उपयोग
Bash के नए संस्करणों के साथ, यह एक-आयामी ऐरे का समर्थन करता है। एक ऐरे को declare शेल-बिल्टइन द्वारा स्पष्ट रूप से घोषित किया जा सकता है।
declare -a var
लेकिन ऊपर की तरह ऐरे वेरिएबल घोषित करना आवश्यक नहीं है। हम सीधे ऐरे में व्यक्तिगत तत्व डाल सकते हैं जैसे:
var[XX]=
जहां 'XX' ऐरे इंडेक्स को दर्शाता है। ऐरे तत्वों को डीरेफरेंस करने के लिए कर्ली ब्रैकेट सिंटैक्स का उपयोग करें, यानी
${var[XX]}
नोट: ऐरे इंडेक्सिंग हमेशा 0 से शुरू होती है।
पूरे ऐरे को इनिशियलाइज़ करने का एक और सुविधाजनक तरीका पैरेंथेसिस की जोड़ी का उपयोग करना है जैसा कि नीचे दिखाया गया है।
var=( element1 element2 element3 . . . elementN )
ऐरे को मान निर्दिष्ट करने का एक और तरीका है। इनिशियलाइज़ेशन का यह तरीका पहले बताई गई विधि की एक उप-श्रेणी है।
array=( [XX]=[XX]= . . . )
हम read शेल-बिल्टइन का उपयोग करके निष्पादन समय के दौरान ऐरे को मान पढ़/निर्दिष्ट भी कर सकते हैं।
read -a array
उपरोक्त स्टेटमेंट को स्क्रिप्ट के अंदर निष्पादित करने पर, यह कुछ इनपुट की प्रतीक्षा करता है। हमें स्पेस द्वारा अलग किए गए ऐरे तत्व प्रदान करने की आवश्यकता है (कैरिज रिटर्न नहीं)। मान दर्ज करने के बाद एंटर दबाकर समाप्त करें।
ऐरे तत्वों को पार करने के लिए हम फॉर लूप का भी उपयोग कर सकते हैं।
for i in "${array[@]}" do #each element as $i को एक्सेस करें . . . done
निम्नलिखित स्क्रिप्ट इस विशेष खंड की सामग्री को सारांशित करती है।
#!/bin/bash array1[0]=one array1[1]=1 echo ${array1[0]} echo ${array1[1]} array2=( one two three ) echo ${array2[0]} echo ${array2[2]} array3=( [9]=nine [11]=11 ) echo ${array3[9]} echo ${array3[11]} read -a array4 for i in "${array4[@]}" do echo $i done exit 0
ऐरे पर विभिन्न ऑपरेशन
कई मानक स्ट्रिंग ऑपरेशन ऐरे पर काम करते हैं। निम्नलिखित नमूना स्क्रिप्ट देखें जो ऐरे पर कुछ ऑपरेशन लागू करती है (स्ट्रिंग ऑपरेशन सहित)।
#!/bin/bash array=( apple bat cat dog elephant frog ) #पहला तत्व प्रिंट करें echo ${array[0]} echo ${array:0} #सभी तत्व प्रदर्शित करें echo ${array[@]} echo ${array[@]:0} #पहले को छोड़कर सभी तत्व प्रदर्शित करें echo ${array[@]:1} #एक रेंज में तत्व प्रदर्शित करें echo ${array[@]:1:4} #पहले तत्व की लंबाई echo ${#array[0]} echo ${#array} #तत्वों की संख्या echo ${#array[*]} echo ${#array[@]} #सबस्ट्रिंग बदलना echo ${array[@]//a/A} exit 0
उपरोक्त स्क्रिप्ट को निष्पादित करने पर निम्नलिखित आउटपुट उत्पन्न होता है।
apple apple apple bat cat dog elephant frog apple bat cat dog elephant frog bat cat dog elephant frog bat cat dog elephant 5 5 6 6 Apple bAt cAt dog elephAnt frog
मुझे लगता है कि उपरोक्त स्क्रिप्ट को विस्तार से समझाने का कोई महत्व नहीं है क्योंकि यह स्व-व्याख्यात्मक है। यदि आवश्यक हो तो मैं इस श्रृंखला में एक भाग विशेष रूप से स्ट्रिंग मैनिपुलेशन पर समर्पित करूंगा।
ऐरे के साथ कमांड सब्स्टीट्यूशन
कमांड सब्स्टीट्यूशन एक कमांड या कई कमांड के आउटपुट को दूसरे संदर्भ में असाइन करता है। यहां ऐरे के इस संदर्भ में हम कमांड के आउटपुट को ऐरे के व्यक्तिगत तत्वों के रूप में डाल सकते हैं। सिंटैक्स इस प्रकार है।
array=( $(command) )
डिफ़ॉल्ट रूप से कमांड के आउटपुट में सामग्री जो व्हाइट स्पेस द्वारा अलग की जाती है, उन्हें ऐरे में व्यक्तिगत तत्वों के रूप में प्लग किया जाता है। निम्नलिखित स्क्रिप्ट एक डायरेक्टरी की सामग्री को सूचीबद्ध करती है, जो 755 परमिशन वाली फ़ाइलें हैं।
#!/bin/bash ERR=27 EXT=0 if [ $# -ne 1 ]; then echo "Usage: $0" exit $ERR fi if [ ! -d $1 ]; then echo "Directory $1 doesn't exists" exit $ERR fi temp=( $(find $1 -maxdepth 1 -type f) ) for i in "${temp[@]}" do perm=$(ls -l $i) if [ `expr ${perm:0:10} : "-rwxr-xr-x"` -eq 10 ]; then echo ${i##*/} fi done exit $EXT
द्वि-आयामी ऐरे का अनुकरण
हम आसानी से एक 2-आयामी मैट्रिक्स को 1-आयामी ऐरे का उपयोग करके प्रस्तुत कर सकते हैं। रो मेजर ऑर्डर प्रतिनिधित्व में मैट्रिक्स की प्रत्येक पंक्ति के तत्व ऐरे इंडेक्स में क्रमिक तरीके से प्रगतिशील रूप से संग्रहीत होते हैं। एक mXn मैट्रिक्स के लिए, इसके लिए सूत्र इस प्रकार लिखा जा सकता है।
matrix[i][j]=array[n*i+j]
2 मैट्रिक्स जोड़ने और परिणामी मैट्रिक्स प्रिंट करने के लिए एक और नमूना स्क्रिप्ट देखें।
#!/bin/bash read -p "Enter the matrix order [mxn] : " t m=${t:0:1} n=${t:2:1} echo "Enter the elements for first matrix" for i in `seq 0 $(($m-1))` do for j in `seq 0 $(($n-1))` do read x[$(($n*$i+$j))] done done echo "Enter the elements for second matrix" for i in `seq 0 $(($m-1))` do for j in `seq 0 $(($n-1))` do read y[$(($n*$i+$j))] z[$(($n*$i+$j))]=$((${x[$(($n*$i+$j))]}+${y[$(($n*$i+$j))]})) done done echo "Matrix after addition is" for i in `seq 0 $(($m-1))` do for j in `seq 0 $(($n-1))` do echo -ne "${z[$(($n*$i+$j))]}\t" done echo -e "\n" done exit 0
भले ही शेल स्क्रिप्टिंग के अंदर ऐरे लागू करने की सीमाएं हैं, यह कुछ स्थितियों में उपयोगी हो जाता है, खासकर जब हम कमांड सब्स्टीट्यूशन के साथ काम करते हैं। एक प्रशासनिक दृष्टिकोण से देखें तो, ऐरे की अवधारणा ने GNU/लिनक्स सिस्टम में कई बैकग्राउंड स्क्रिप्ट के विकास का मार्ग प्रशस्त किया।
