Le code suivant crée et imprime un tableau de chaînes dans Shell:
#!/bin/bash
array=("A" "B" "ElementC" "ElementE")
for element in "${array[@]}"
do
echo "$element"
done
echo
echo "Number of elements: ${#array[@]}"
echo
echo "${array[@]}"
Résultat:
A
B
ElementC
ElementE
Number of elements: 4
A B ElementC ElementE
en bash, vous créez un tableau comme celui-ci
arr=(one two three)
appeler les éléments
$ echo "${arr[0]}"
one
$ echo "${arr[2]}"
three
pour demander une entrée utilisateur, vous pouvez utiliser read
read -p "Enter your choice: " choice
Bourne Shell ne supporte pas les tableaux. Cependant, il existe deux façons de gérer le problème.
Utiliser les paramètres de shell positionnels $ 1, $ 2, etc.:
$ set one two three
$ echo $*
one two three
$ echo $#
3
$ echo $2
two
Utilisez des évaluations variables:
$ 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
#!/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
Vous pouvez lire le guide ABS "Advanced Bash-Scripting Guide"
Bourne Shell et C Shell n'ont pas de tableaux, IIRC.
En plus de ce que d'autres ont dit, dans Bash, vous pouvez obtenir le nombre d'éléments d'un tableau comme suit:
elements=${#arrayname[@]}
et faire des opérations de type slice:
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"
Essaye ça :
echo "Find the Largest Number and Smallest Number of a given number"
echo "---------------------------------------------------------------------------------"
echo "Enter the number"
read n
while [ $n -gt 0 ] #For Seperating digits and Stored into array "x"
do
x[$i]=`expr $n % 10`
n=`expr $n / 10`
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"
Votre question concerne "les scripts shell unix", mais porte la mention bash. Ce sont deux réponses différentes.
La spécification POSIX pour les shells ne dit rien sur les tableaux, car Bourne Shell d'origine ne les supportait pas. Même aujourd'hui, sur FreeBSD, Ubuntu Linux et de nombreux autres systèmes, /bin/sh ne prend pas en charge la matrice. Donc, si vous voulez que votre script fonctionne dans différents shells compatibles Bourne, vous ne devriez pas les utiliser. Si vous envisagez un shell spécifique, vous pouvez également indiquer son nom complet dans la ligne Shebang, par exemple. #!/usr/bin/env bash.
Si vous utilisez bash ou zsh , ou une version moderne de ksh , vous pouvez créer un tableau comme celui-ci:
myArray=(first "second element" 3rd)
et accéder à des éléments comme celui-ci
$ echo "${myArray[1]}"
second element
Vous pouvez obtenir tous les éléments via "${myArray[@]}". Vous pouvez utiliser la notation de tranche $ {array [@]: start: length} pour restreindre la partie du tableau référencé, par exemple. "${myArray[@]:1}" pour laisser le premier élément.
La longueur du tableau est ${#myArray[@]}. Vous pouvez obtenir un nouveau tableau contenant tous les index d'un tableau existant avec "${!myArray[@]}".
Les anciennes versions de ksh antérieures à ksh93 comportaient également des tableaux, mais pas la notation basée sur la parenthèse, ni la prise en charge du découpage en tranches. Vous pouvez créer un tableau comme ceci, cependant:
set -A myArray -- first "second element" 3rd
Un tableau peut être chargé en deux semaines.
set -A TEST_ARRAY alpha beta gamma
ou
X=0 # Initialize counter to zero.
- Chargez le tableau avec les chaînes alpha, beta et gamma
for ELEMENT in alpha gamma beta
do
TEST_ARRAY[$X]=$ELEMENT
((X = X + 1))
done
De plus, je pense que les informations ci-dessous peuvent aider:
Le shell prend en charge les tableaux unidimensionnels. Le nombre maximum de tableau éléments est 1,024. Quand un tableau est défini, il est automatiquement dimensionné à 1.024 éléments. Un tableau à une dimension contient un séquence d'éléments du tableau, qui sont comme les wagons connectés connectés ensemble sur une voie de train.
Si vous souhaitez accéder au tableau:
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
Vous pouvez essayer du type suivant:
#!/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
Si vous souhaitez un magasin de valeurs de clé avec prise en charge des espaces, utilisez le paramètre -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 "Les tableaux associatifs sont créés à l'aide de declare -A nom."
Il existe plusieurs façons de créer un tableau dans Shell.
ARR[0]="ABC"
ARR[1]="BCD"
echo ${ARR[*]}
${ARR[*]} affiche tous les éléments du tableau.
La deuxième façon est:
ARR=("A" "B" "C" "D" 5 7 "J")
echo ${#ARR[@]}
echo ${ARR[0]}
${#ARR[@]} est utilisé pour compter la longueur du tableau.
Pour lire les valeurs du clavier et insérer un élément dans un tableau
# 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
Un moyen simple:
arr=("sharlock" "bomkesh" "feluda" ) ##declare array
len=${#arr[*]} #determine length of array
# iterate with for loop
for (( i=0; i<len; i++ ))
do
echo ${arr[$i]}
done
En ksh vous le faites:
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 )) ]}