हम सरणियों की अवधारणा के बिना प्रोग्रामिंग भाषा की कल्पना नहीं कर सकते। इससे कोई फर्क नहीं पड़ता कि उन्हें विभिन्न भाषाओं में कैसे लागू किया जाता है। इसके बजाय सरणियाँ हमें एक प्रतीकात्मक नाम के तहत समान या भिन्न डेटा को समेकित करने में मदद करती हैं।
यहाँ जैसा कि हम शेल स्क्रिप्टिंग के बारे में चिंतित हैं, यह लेख आपको कुछ शेल स्क्रिप्ट के साथ खेलने में मदद करेगा जो सरणियों की इस अवधारणा का उपयोग करती हैं।
सरणी प्रारंभ और उपयोग
बैश के नए संस्करणों के साथ, यह एक-आयामी सरणियों का समर्थन करता है। एक सरणी को स्पष्ट रूप से घोषणा . द्वारा घोषित किया जा सकता है शेल-बिल्टिन।
declare -a var
लेकिन उपरोक्त के रूप में सरणी चर घोषित करना आवश्यक नहीं है। हम अलग-अलग तत्वों को सीधे निम्नानुसार सरणी में सम्मिलित कर सकते हैं।
var[XX]=<value>
जहां 'XX' सरणी अनुक्रमणिका को दर्शाता है। सरणी तत्वों को डीरेफरेंस करने के लिए कर्ली ब्रैकेट सिंटैक्स का उपयोग करें, अर्थात
${var[XX]}
नोट :ऐरे इंडेक्सिंग हमेशा 0 से शुरू होती है।
एक संपूर्ण सरणी को प्रारंभ करने का एक अन्य सुविधाजनक तरीका नीचे दिखाए गए अनुसार कोष्ठक के युग्म का उपयोग करना है।
var=( element1 element2 element3 . . . elementN )
सरणियों को मान निर्दिष्ट करने का एक और तरीका है। आरंभीकरण का यह तरीका पहले बताई गई विधि की उप-श्रेणी है।
array=( [XX]=<value> [XX]=<value> . . . )
हम निष्पादन समय के दौरान पढ़ें . का उपयोग करके सरणी को मान पढ़/असाइन कर सकते हैं शेल-बिल्टिन।
read -a array
अब उपरोक्त कथन को एक स्क्रिप्ट के अंदर निष्पादित करने पर, यह कुछ इनपुट की प्रतीक्षा करता है। हमें अंतरिक्ष द्वारा अलग किए गए सरणी तत्व प्रदान करने की आवश्यकता है (और कैरिज रिटर्न नहीं)। मान दर्ज करने के बाद समाप्त करने के लिए एंटर दबाएं।
सरणी तत्वों के माध्यम से पार करने के लिए हम लूप के लिए भी उपयोग कर सकते हैं।
for i in “${array[@]}”
do
#access 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 )
#print first element
echo ${array[0]}
echo ${array:0}
#display all elements
echo ${array[@]}
echo ${array[@]:0}
#display all elements except first one
echo ${array[@]:1}
#display elements in a range
echo ${array[@]:1:4}
#length of first element
echo ${#array[0]}
echo ${#array}
#number of elements
echo ${#array[*]}
echo ${#array[@]}
#replacing substring
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 <path>"
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
दो-आयामी सरणियों का अनुकरण
हम 1-आयामी सरणी का उपयोग करके आसानी से 2-आयामी मैट्रिक्स का प्रतिनिधित्व कर सकते हैं। पंक्ति प्रमुख क्रम . में मैट्रिक्स की प्रत्येक पंक्ति में प्रतिनिधित्व तत्वों को क्रमिक रूप से सरणी अनुक्रमणिका में क्रमिक रूप से संग्रहीत किया जाता है। एक एमएक्सएन मैट्रिक्स के लिए, उसी के लिए सूत्र इस प्रकार लिखा जा सकता है।
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
भले ही शेल स्क्रिप्टिंग के अंदर सरणियों को लागू करने की सीमाएँ हैं, यह मुट्ठी भर स्थितियों में उपयोगी हो जाता है, खासकर जब हम कमांड प्रतिस्थापन के साथ काम करते हैं। प्रशासनिक दृष्टिकोण से देखें तो सरणियों की अवधारणा ने जीएनयू/लिनक्स सिस्टम में कई पृष्ठभूमि स्क्रिप्ट के विकास का मार्ग प्रशस्त किया।