मैं यूनिक्स शेल स्क्रिप्टिंग में एक सरणी कैसे बना सकता हूं?
जवाबों:
निम्न कोड शेल में स्ट्रिंग्स की एक सरणी बनाता है और प्रिंट करता है:
#!/bin/bash
array=("A" "B" "ElementC" "ElementE")
for element in "${array[@]}"
do
echo "$element"
done
echo
echo "Number of elements: ${#array[@]}"
echo
echo "${array[@]}"
परिणाम:
A
B
ElementC
ElementE
Number of elements: 4
A B ElementC ElementE
बाश में, आप इस तरह सरणी बनाते हैं
arr=(one two three)
तत्वों को बुलाने के लिए
$ echo "${arr[0]}"
one
$ echo "${arr[2]}"
three
उपयोगकर्ता इनपुट के लिए पूछने के लिए, आप पढ़ सकते हैं
read -p "Enter your choice: " choice
/bin/shत्रुटि को फेंकने के साथ काम नहीं करती है line 1: syntax error: unexpected "("। क्या आप एक विकल्प के बारे में जानते हैं?
बॉर्न शेल सरणियों का समर्थन नहीं करता है। हालांकि, मुद्दे को संभालने के दो तरीके हैं।
$ 1, $ 2, आदि की स्थिति के लिए शेल के मापदंडों का उपयोग करें:
$ set one two three
$ echo $*
one two three
$ echo $#
3
$ echo $2
two
चर मूल्यांकन का उपयोग करें:
$ n=1 ; eval a$n="one"
$ n=2 ; eval a$n="two"
$ n=3 ; eval a$n="three"
$ n=2
$ eval echo \$a$n
two
bash(यह बंदरगाहों से स्थापित करने योग्य है)। लिखी गई bashविशेषताओं का वर्णन पोर्टेबल नहीं है, और वे ज्यादातर बॉर्न शेल कार्यान्वयनों की तुलना में धीमी गति से धीमी हैं (जैसे dash, जो कि जीएनयू / लिनक्स वितरण पर आम है)। bashएक अच्छा इंटरैक्टिव शेल है, लेकिन यह स्क्रिप्टिंग के लिए धीमा है।
$*हानिकारक माना जाता है। आम तौर पर, $@पसंद किया जाता है क्योंकि यह वही करता है, लेकिन रिक्त स्थान रखता है। $@, "$ 1" "$ 2" "$ 3" ... "$ n" के रूप में विस्तारित करते हुए किया जाता है $*के रूप में "$ 1x $ 2x $ 3x ... $ n", जहां विस्तार किया जाता है xहै $IFSविभाजक (सबसे अधिक संभावना है, अंतरिक्ष)।
$@वैसा ही है $*; अंतर केवल तभी प्रकट होता है जब उद्धृत किया जाता है: "$*"एक शब्द है, जबकि "$@"मूल शब्द टूटता है।
bash, इसलिए बैश-विशिष्ट प्रतिक्रियाएं उपयुक्त हैं, लेकिन यह निश्चित रूप से सच है कि किसी को यह नहीं मानना चाहिए कि /bin/shबैश है।
#!/bin/bash
# define a array, space to separate every item
foo=(foo1 foo2)
# access
echo "${foo[1]}"
# add or changes
foo[0]=bar
foo[2]=cat
foo[1000]=also_OK
आप ABS "एडवांस बैश-स्क्रिप्टिंग गाइड" पढ़ सकते हैं
/bin/shत्रुटि को फेंकने के साथ काम नहीं करती है line 1: syntax error: unexpected "("। क्या आप एक विकल्प के बारे में जानते हैं?
बॉर्न शेल और सी शेल में एरेज़, IIRC नहीं है।
बाश में दूसरों ने जो कहा है, उसके अलावा, आप एक सरणी में तत्वों की संख्या निम्नानुसार प्राप्त कर सकते हैं:
elements=${#arrayname[@]}
और स्लाइस-शैली संचालन करें:
arrayname=(apple banana cherry)
echo ${arrayname[@]:1} # yields "banana cherry"
echo ${arrayname[@]: -1} # yields "cherry"
echo ${arrayname[${#arrayname[@]}-1]} # yields "cherry"
echo ${arrayname[@]:0:2} # yields "apple banana"
echo ${arrayname[@]:1:1} # yields "banana"
setकमांड के प्रलेखन ( set name=(wordlist)) और "चर सबस्टेशन" खंड ( $name[selector]और ${name[selector]}) देखें। जहाँ तक मुझे पता है, csh ने हमेशा सरणियों का समर्थन किया है। उदाहरण के लिए, $pathऐरे वेरिएबल को देखें, जो $PATHपर्यावरण वैरिएबल को मिरर करता है।
इसे इस्तेमाल करे :
echo "Find the Largest Number and Smallest Number of a given number"
echo "---------------------------------------------------------------------------------"
echo "Enter the number"
read n
i=0
while [ $n -gt 0 ] #For Seperating digits and Stored into array "x"
do
x[$i]=`expr $n % 10`
n=`expr $n / 10`
i=`expr $i + 1`
done
echo "Array values ${x[@]}" # For displaying array elements
len=${#x[*]} # it returns the array length
for (( i=0; i<len; i++ )) # For Sorting array elements using Bubble sort
do
for (( j=i+1; j<len; j++ ))
do
if [ `echo "${x[$i]} > ${x[$j]}"|bc` ]
then
t=${x[$i]}
t=${x[$i]}
x[$i]=${x[$j]}
x[$j]=$t
fi
done
done
echo "Array values ${x[*]}" # Displaying of Sorted Array
for (( i=len-1; i>=0; i-- )) # Form largest number
do
a=`echo $a \* 10 + ${x[$i]}|bc`
done
echo "Largest Number is : $a"
l=$a #Largest number
s=0
while [ $a -gt 0 ] # Reversing of number, We get Smallest number
do
r=`expr $a % 10`
s=`echo "$s * 10 + $r"|bc`
a=`expr $a / 10`
done
echo "Smallest Number is : $s" #Smallest Number
echo "Difference between Largest number and Smallest number"
echo "=========================================="
Diff=`expr $l - $s`
echo "Result is : $Diff"
echo "If you try it, We can get it"
आपका प्रश्न "यूनिक्स शेल स्क्रिप्टिंग" के बारे में पूछता है, लेकिन टैग किया गया है bash। वे दो अलग-अलग उत्तर हैं।
गोले के POSIX विनिर्देश में सरणियों के बारे में कहने के लिए कुछ भी नहीं है, क्योंकि मूल बॉर्न शेल ने उनका समर्थन नहीं किया था। आज भी, FreeBSD, उबंटू लिनक्स, और कई अन्य प्रणालियों पर, /bin/shसरणी का समर्थन नहीं है। इसलिए यदि आप चाहते हैं कि आपकी स्क्रिप्ट विभिन्न बॉर्न-संगत गोले में काम करे, तो आपको उनका उपयोग नहीं करना चाहिए। वैकल्पिक रूप से, यदि आप एक विशिष्ट शेल मान रहे हैं, तो इसका पूरा नाम शेबंग लाइन में रखना सुनिश्चित करें, जैसे #!/usr/bin/env bash।
यदि आप बैश या zsh , या ksh के आधुनिक संस्करण का उपयोग कर रहे हैं , तो आप इस तरह से एक सरणी बना सकते हैं:
myArray=(first "second element" 3rd)
और इस तरह से तत्वों का उपयोग
$ echo "${myArray[1]}"
second element
आप सभी तत्वों को प्राप्त कर सकते हैं "${myArray[@]}"। आप संदर्भित किए गए एरे के भाग को प्रतिबंधित करने के लिए स्लाइस नोटेशन $ {array [@]: start: length} का उपयोग कर सकते हैं , जैसे "${myArray[@]:1}"पहले तत्व को छोड़ना।
सरणी की लंबाई है ${#myArray[@]}। आप मौजूदा सरणी से सभी अनुक्रमित युक्त एक नया सरणी प्राप्त कर सकते हैं "${!myArray[@]}"।
Ksh93 से पहले ksh के पुराने संस्करणों में भी सरणियाँ थीं, लेकिन कोष्ठक-आधारित संकेतन नहीं था, न ही उन्होंने स्लाइसिंग का समर्थन किया था। आप इस तरह एक सरणी बना सकते हैं, हालांकि:
set -A myArray -- first "second element" 3rd
आप निम्न प्रकार की कोशिश कर सकते हैं:
#!/bin/bash
declare -a arr
i=0
j=0
for dir in $(find /home/rmajeti/programs -type d)
do
arr[i]=$dir
i=$((i+1))
done
while [ $j -lt $i ]
do
echo ${arr[$j]}
j=$((j+1))
done
एक सरणी को जुड़वाँ में लोड किया जा सकता है।
set -A TEST_ARRAY alpha beta gamma
या
X=0 # Initialize counter to zero.
- स्ट्रिंग को अल्फा, बीटा, और गामा के साथ सरणी लोड करें
for ELEMENT in alpha gamma beta
do
TEST_ARRAY[$X]=$ELEMENT
((X = X + 1))
done
इसके अलावा, मुझे लगता है कि नीचे दी गई जानकारी से मदद मिल सकती है:
खोल एक आयामी सरणियों का समर्थन करता है। सरणी तत्वों की अधिकतम संख्या 1,024 है। जब एक सरणी को परिभाषित किया जाता है, तो यह स्वचालित रूप से 1,024 तत्वों के लिए आयामित होता है। एक-आयामी सरणी में सरणी तत्वों का एक क्रम होता है, जो एक ट्रेन ट्रैक पर एक साथ जुड़े बॉक्सकार की तरह होते हैं।
मामले में आप सरणी का उपयोग करना चाहते हैं:
echo ${MY_ARRAY[2] # Show the third array element
gamma
echo ${MY_ARRAY[*] # Show all array elements
- alpha beta gamma
echo ${MY_ARRAY[@] # Show all array elements
- alpha beta gamma
echo ${#MY_ARRAY[*]} # Show the total number of array elements
- 3
echo ${#MY_ARRAY[@]} # Show the total number of array elements
- 3
echo ${MY_ARRAY} # Show array element 0 (the first element)
- alpha
यदि आप रिक्त स्थान के लिए समर्थन के साथ एक महत्वपूर्ण मान चाहते हैं तो -Aपैरामीटर का उपयोग करें :
declare -A programCollection
programCollection["xwininfo"]="to aquire information about the target window."
for program in ${!programCollection[@]}
do
echo "The program ${program} is used ${programCollection[${program}]}"
done
http://linux.die.net/man/1/bash "घोषित ऐ-नाम का उपयोग करके सहयोगी सरणियाँ बनाई गई हैं।"
शेल में एक सरणी बनाने के कई तरीके हैं।
ARR[0]="ABC"
ARR[1]="BCD"
echo ${ARR[*]}
${ARR[*]} सरणी में सभी तत्वों को प्रिंट करता है।
दूसरा तरीका है:
ARR=("A" "B" "C" "D" 5 7 "J")
echo ${#ARR[@]}
echo ${ARR[0]}
${#ARR[@]} का उपयोग सरणी की लंबाई को गिनने के लिए किया जाता है।
कीबोर्ड से मान पढ़ने के लिए और एरे में एलिमेंट डालें
# enter 0 when exit the insert element
echo "Enter the numbers"
read n
while [ $n -ne 0 ]
do
x[$i]=`expr $n`
read n
let i++
done
#display the all array elements
echo "Array values ${x[@]}"
echo "Array values ${x[*]}"
# To find the array length
length=${#x[*]}
echo $length
Ksh में आप इसे करते हैं:
set -A array element1 element2 elementn
# view the first element
echo ${array[0]}
# Amount elements (You have to substitute 1)
echo ${#array[*]}
# show last element
echo ${array[ $(( ${#array[*]} - 1 )) ]}
echo "${array[@]:(-1)}"। यह सरणी चर नाम को दो बार लिखने की आवश्यकता को समाप्त करता है।