ऐरे में

ऐरे के बारे में

Bash दो तरह के पैरामीटर देता है: "स्केलर" वैल्यू और ऐरे। एक स्केलर वैल्यू स्ट्रिंग या संख्या हो सकती है; यह एक अकेली चीज़ को दर्शाती है।

ज़्यादातर मामलों में आपका डेटा रखने के लिए स्केलर वैल्यू ही काफी होती हैं। लेकिन कभी-कभी आपको स्केलर वैल्यू की एक सूची संग्रहीत करनी पड़ती है। ऐसे में आप एक ऐरे इस्तेमाल करते हैं।

ऐरे दो तरह के होते हैं:

• संख्यात्मक इंडेक्स वाले ऐरे पूर्णांक की को एक स्ट्रिंग वैल्यू से जोड़ते हैं। (दूसरी भाषाएँ इसे "list" या "sequence" कह सकती हैं।)
• एसोसिएटिव ऐरे स्ट्रिंग की को एक स्ट्रिंग वैल्यू से जोड़ते हैं। (दूसरी भाषाएँ इसे "map" या "dictionary" कह सकती हैं।)

इस दस्तावेज़ के शुरुआती कुछ भाग संख्यात्मक इंडेक्स वाले ऐरे के बारे में हैं (आगे इन्हें सिर्फ "ऐरे" कहा जाएगा)। एसोसिएटिव ऐरे की जानकारी अंत में मिलेगी।

ऐरे वेरिएबल घोषित करना और इनिशियलाइज़ करना

आप एक वेरिएबल को ब्रैकेट में लिखी एलिमेंट की सूची (खाली भी हो सकती है) असाइन करके ऐरे इनिशियलाइज़ कर सकते हैं।

myarray=("one" "two" "three")

हर वेरिएबल असाइनमेंट की तरह, बराबर के चिह्न के दोनों ओर कोई स्पेस नहीं होना चाहिए।

ध्यान दीजिए कि एलिमेंट के बीच कोई कॉमा नहीं होता; यह स्ट्रिंग की एक ऐसी सूची है जिसमें हर स्ट्रिंग को स्पेस से अलग किया जाता है।

दरअसल, ब्रैकेट के अंदर स्पेस कितनी भी हो सकती है। नई लाइनें भी चलती हैं; पढ़ने में आसानी के लिए जितनी चाहें उतनी डालिए।

myarray=(
    "first element"
    "second element"
    "this is the last element"
)

इस तरह स्ट्रिंग की सूची ऐरे वेरिएबल को असाइन करने पर पहली स्ट्रिंग इंडेक्स शून्य पर, अगली इंडेक्स एक पर, उसके बाद वाली इंडेक्स दो पर संग्रहीत होती है, और इसी तरह आगे भी।

आप "स्पार्स ऐरे" को सिर्फ उन्हीं इंडेक्स को लिखकर इनिशियलाइज़ कर सकते हैं जिनकी आपको ज़रूरत है।

raindrops=([3]="Pling" [5]="Plang" [7]="Plong")

myarray=("one" "two" "three")
[[ "${myarray[0]}" == "one" ]] && echo true || echo false

आप declare कमांड (या फंक्शन के अंदर local) इस्तेमाल करके बता सकते हैं कि यह वेरिएबल एक ऐरे रखेगा।

declare -a myarray

वेरिएबल को इनिशियलाइज़ करने का ज़्यादा प्रचलित तरीका यह है कि उसे ब्रैकेट में लिखी (शायद खाली) सूची सीधे असाइन कर दी जाए।

ऐरे के एलिमेंट ऐक्सेस करना

जैसा आपने ऊपर दिए नोट में देखा, ऐरे का कोई एलिमेंट ऐक्सेस करने का सिंटैक्स ${myarray[$index]} है। इंडेक्स चौकोर ब्रैकेट में लिखा जाता है। ये घुंघराले ब्रैकेट ज़रूरी हैं।

i=5
echo "${myarray[i]}"
# ..............^

अगर दिया गया इंडेक्स ऐरे में मौजूद नहीं है, तो एक्सपैंशन का परिणाम एक खाली स्ट्रिंग होता है।

ऐरे में वैल्यू असाइन करना

ऐरे की किसी खास एंट्री को वैल्यू देने के लिए यह सिंटैक्स इस्तेमाल कीजिए:

myarray[10]="hello"

ऐरे में नया एलिमेंट जोड़ने के लिए += (जोड़ने वाला असाइनमेंट) ऑपरेटर इस्तेमाल कीजिए और साथ में ब्रैकेट भी लगाइए:

myarray+=("new element 1" "new element 2")

ऐरे पर इटरेशन करना

आम तौर पर आपको ऐरे की वैल्यू पर एक-एक करके इटरेशन करना पड़ता है। इसके लिए for लूप इस्तेमाल कीजिए (जो आपने लूपिंग कॉन्सेप्ट में देखा था):

myarray=("one" "two" "three")
for value in "${myarray[@]}"; do
    echo "$value"
done

ऐरे को एक्सपैंड करने का खास सिंटैक्स ध्यान दीजिए: "${myarray[@]}" पैरामीटर एक्सपैंशन का यह रूप ऐरे की वैल्यू को अलग-अलग शब्दों के रूप में रखता है। यह लगभग इसके बराबर है:

for value in "${myarray[0]}" "${myarray[1]}" ... "${myarray[n]}"

"${myarray[@]}" वाला रूप स्पार्स ऐरे के साथ भी काम करता है और सिर्फ उन्हीं वैल्यू तक फैलता है जो तय की गई हैं।

यह खास एक्सपैंशन, जिसमें इंडेक्स की जगह एम्परसैंड (@) होता है, सिर्फ डबल कोट के अंदर ही खास रहता है।

कुछ और खास पैरामीटर एक्सपैंशन

ऐरे पर इटरेशन करने के लिए हमें कुछ और खास सिंटैक्स की भी ज़रूरत पड़ती है। इनका वर्णन मैनुअल में शेल पैरामीटर एक्सपैंशन में मिलता है।

ऐरे की लंबाई पता करने के लिए ${#myarray[@]} इस्तेमाल कीजिए, यानी नाम से पहले # लगाइए। ऐरे की "लंबाई" का मतलब है उसमें मौजूद एलिमेंट की संख्या।

ऐरे के इंडेक्स की सूची निकालने के लिए "${!myarray[@]}" इस्तेमाल कीजिए, यानी नाम से पहले ! लगाइए और एक्सपैंशन को डबल कोट में रखिए। संख्यात्मक इंडेक्स वाले ऐरे में इंडेक्स संख्याओं के क्रम में एक्सपैंड होते हैं।

ऐरे के इंडेक्स पर इटरेशन करना

कभी-कभी आपको वैल्यू के साथ इंडेक्स भी चाहिए होता है। इसके लिए दो तरीके हैं।

1. जब आपको पता हो कि इंडेक्स लगातार हैं, तो आप अंकगणितीय for लूप इस्तेमाल कर सकते हैं।

   for ((i = 0; i < ${#myarray[@]}; i++)); do
       echo "$i -> ${myarray[i]}"
   done
   

   यहाँ ${#myarray[@]} सिंटैक्स देखिए, जिसमें ऐरे के नाम से पहले # अक्षर लगता है। चूँकि ऐरे में इंडेक्स शून्य से शुरू होते हैं, ऐरे का अंतिम इंडेक्स उसकी लंबाई से एक कम होता है।

2. जब ऐरे स्पार्स हो, तो आप यह रूप इस्तेमाल कर सकते हैं:

   for index in "${!raindrops[@]}"; do
       echo "$index -> ${raindrops[index]}"
   done
   

   यहाँ ${!myarray[@]} सिंटैक्स देखिए, जिसमें ऐरे के नाम से पहले ! अक्षर लगता है।

ऐरे की जाँच करना

अगर आप ऐरे की सामग्री देखना चाहते हैं, तो declare कमांड के साथ -p ऑप्शन इस्तेमाल कीजिए:

a=("the 'first' element"
   second
   third
   'the "last" element')
declare -p a

यह सामग्री को कैनोनिकल शेल कोटिंग के साथ आउटपुट करता है।

declare -a a=([0]="the 'first' element" [1]="second" [2]="third" [3]="the \"last\" element")

एसोसिएटिव ऐरे

एक बार फिर: एसोसिएटिव ऐरे इंडेक्स के लिए संख्याओं की जगह स्ट्रिंग इस्तेमाल करते हैं। ऊपर लिखी हर बात एसोसिएटिव ऐरे पर भी लागू होती है, बस थोड़े फर्क के साथ। आम तौर पर हम "इंडेक्स" नहीं, "की" शब्द इस्तेमाल करते हैं: एसोसिएटिव ऐरे की को वैल्यू से जोड़ते हैं।

एसोसिएटिव ऐरे घोषित करना

ऐरे के उलट, एसोसिएटिव ऐरे ज़रूर घोषित करने पड़ते हैं। declare के साथ -A ऑप्शन इस्तेमाल कीजिए (या फंक्शन के अंदर local):

declare -A mymap

myfunc() {
    local -A my_local_map
    # ...
}

एसोसिएटिव ऐरे इनिशियलाइज़ करना

की-वैल्यू जोड़े ब्रैकेट में लिखी सूची के अंदर दिए जाते हैं:

mymap=([first]=foo [second]=bar [third]=baz)
declare -p mymap

यह आउटपुट देता है:

declare -A mymap=([second]="bar" [first]="foo" [third]="baz")

घोषणा और इनिशियलाइज़ेशन एक ही लाइन में हो सकते हैं।

declare -A mymap=([first]=foo [second]=bar [third]=baz)

Bash के नए वर्शन में इनिशियलाइज़ेशन के लिए (key value key value ...) जैसी सूची भी इस्तेमाल की जा सकती है।

declare -A mymap=(first foo second bar third baz)

वैल्यू ऐक्सेस करना

एलिमेंट ऐक्सेस करने के लिए पहले जैसा ही सिंटैक्स इस्तेमाल होता है: ${mymap[$key]}।

एसोसिएटिव ऐरे की की को अंकगणितीय संदर्भ में नहीं समझा जाता। इसके लिए सामान्य पैरामीटर एक्सपैंशन सिंटैक्स की ज़रूरत पड़ती है।

एसोसिएटिव ऐरे में वैल्यू असाइन करना

असाइनमेंट के लिए पहले जैसा ही सिंटैक्स इस्तेमाल होता है:

mymap[$key]="$value"

इटरेशन करना

इटरेशन के लिए आप for value in "${mymap[@]}" लूप इस्तेमाल कर सकते हैं। लेकिन आम तौर पर आपको वैल्यू के साथ की भी चाहिए होती है।

इसके लिए ऊपर देखा गया "${!mymap[@]}" सिंटैक्स इस्तेमाल कीजिए।

for key in "${!mymap[@]}"; do
    echo "$key -> ${mymap[$key]}"
done

यह आउटपुट देता है

second -> bar
first -> foo
third -> baz

एक बार फिर ज़ोर देकर: की के क्रम का कोई निश्चित मतलब नहीं होता।