Arrays en shell Unix?

¿Cómo creo una matriz en scripts de shell unix?

El siguiente código crea e imprime una matriz de cadenas en 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[@]}" 

Resultado:

 A B ElementC ElementE Number of elements: 4 AB ElementC ElementE 

en bash, creas una matriz como esta

 arr=(one two three) 

llamar a los elementos

 $ echo "${arr[0]}" one $ echo "${arr[2]}" three 

para solicitar la entrada del usuario, puede usar leer

 read -p "Enter your choice: " choice 

Bourne shell no admite matrices. Sin embargo, hay dos formas de manejar el problema.

Use parámetros de carcasa posicional $ 1, $ 2, etc.

 $ set one two three $ echo $* one two three $ echo $# 3 $ echo $2 two 

Usar evaluaciones de 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 

Puede leer el ABS “Advanced Bash-Scripting Guide”

Prueba esto :

 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 ${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" 

Su pregunta se refiere a “secuencias de comandos shell de Unix”, pero está etiquetada como bash . Esas son dos respuestas diferentes.

La especificación POSIX para shells no tiene nada que decir sobre los arrays, ya que el shell Bourne original no los soportaba. Incluso hoy, en FreeBSD, Ubuntu Linux y muchos otros sistemas, /bin/sh no tiene soporte de matriz. Por lo tanto, si desea que su script funcione en diferentes shells compatibles con Bourne, no debe usarlos. Alternativamente, si está asumiendo un shell específico, asegúrese de poner su nombre completo en la línea shebang, por ejemplo, #!/usr/bin/env bash .

Si está utilizando bash o zsh , o una versión moderna de ksh , puede crear una matriz como esta:

 myArray=(first "second element" 3rd) 

y acceder a elementos como este

 $ echo "${myArray[1]}" second element 

Puede obtener todos los elementos a través de "${myArray[@]}" . Puede usar la notación de división $ {array [@]: start: length} para restringir la parte de la matriz a la que se hace referencia, por ejemplo, "${myArray[@]:1}" para dejar fuera el primer elemento.

La longitud de la matriz es ${#myArray[@]} . Puede obtener una nueva matriz que contenga todos los índices de una matriz existente con "${!myArray[@]}" .

Las versiones anteriores de ksh antes de ksh93 también tenían matrices, pero no la notación basada en paréntesis, ni admitían el corte. Sin embargo, puedes crear una matriz como esta:

 set -A myArray -- first "second element" 3rd 

El shell Bourne y el shell C no tienen matrices, IIRC.

Además de lo que otros han dicho, en Bash puedes obtener la cantidad de elementos en una matriz de la siguiente manera:

 elements=${#arrayname[@]} 

y hacer operaciones de corte de estilo:

 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" 

Una matriz se puede cargar en twoways.

 set -A TEST_ARRAY alpha beta gamma 

o

 X=0 # Initialize counter to zero. 

– Cargue la matriz con las cadenas alfa, beta y gamma

 for ELEMENT in alpha gamma beta do TEST_ARRAY[$X]=$ELEMENT ((X = X + 1)) done 

Además, creo que la siguiente información puede ayudar:

El shell admite matrices unidimensionales. La cantidad máxima de elementos de matriz es 1.024. Cuando se define una matriz, se dimensiona automáticamente a 1,024 elementos. Una matriz unidimensional contiene una secuencia de elementos de matriz, que son como los vagones de carga conectados entre sí en una vía férrea.

En caso de que quiera acceder a la matriz:

 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 

Puedes probar del siguiente tipo:

 #!/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 desea un almacén de valores clave con soporte para espacios, use el parámetro -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 “Las matrices asociativas se crean usando declarar-un nombre”.

Para leer los valores de keybord e insertar elemento en matriz

 # 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 

En ksh lo haces:

 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 )) ]} 

Una manera simple:

 arr=("sharlock" "bomkesh" "feluda" ) ##declare array len=${#arr[*]} #determine length of array # iterate with for loop for (( i=0; i