Las arrays son conceptos importantes en la programación o creación de scripts. Las arrays nos permiten almacenar y recuperar elementos en forma de lista que se pueden usar para ciertas tareas. En bash, también tenemos arrays que nos ayudan a crear scripts en la línea de comandos para almacenar datos en formato de lista. En este artículo, comprenderemos los conceptos básicos de las arrays en scripts de bash.
Creación de arrays
Para crear una array básica en un script bash, podemos usar el comando declare -a seguido del nombre de la variable de array que le gustaría dar.
#!/bin/usr/env bash declare -a sport=( [0]=football [1]=cricket [2]=hockey [3]=basketball )
O
#!/bin/usr/env bash sport[0]=football sport[1]=cricket sport[2]=hockey sport[3]=basketball
El valor de los elementos puede ser cualquier número entero o strings o cualquier otra forma de datos que se desee. Podemos ver que la array se declara en un script bash de dos maneras: la primera parece más conveniente y menos agitada de declarar. Si queremos declarar la array de una sola vez, la primera es la opción óptima, pero si los elementos se van a agregar en partes, la última es una buena opción.
Imprimiendo las arrays
Después de declarar la array, si queremos mostrar todos los elementos de la array, podemos usar el símbolo @.
#!/bin/usr/env bash
declare -a sport=(
[0]=football
[1]=cricket
[2]=hockey
[3]=basketball
)
echo "${sport[@]}"
echo "${array_name[@]}"
Usamos [@] como índice de la array para mostrar todos los elementos. Todos los elementos se imprimen separados por espacios. Las comillas alrededor de la variable se expanden e imprimen todos los elementos de la array.
Iterando sobre la array
Para iterar sobre un arreglo elemento a elemento, podemos usar bucles y realizar cualquier operación dentro del cuerpo del mismo.
#!/bin/usr/env bash
declare -a sport=(
[0]=football
[1]=cricket
[2]=hockey
[3]=basketball
)
for i in ${nums[@]}
do
echo -e "$i \n"
done
Como podemos ver, hemos usado un ciclo for para imprimir el elemento de la array uno por uno. Hemos usado el truco en la sección anterior de obtener todos los elementos de la array e iterarlo uno por uno en el bucle for a. El “${array_name[@]}” se expande en todos los elementos de la array y el bucle for itera sobre ellos uno por uno con el iterador en el ejemplo es la variable i , dentro del cuerpo del bucle for imprimimos el variable/iterador i y, por lo tanto, iterar sobre la array.
Obtener el número de elementos en el Array
Para obtener el número de la array de elementos, podemos usar el operador # antes del nombre de la array en la s en «${array_name[@]}».
#!/bin/usr/env bash
declare -a sport=(
[0]=football
[1]=cricket
[2]=hockey
[3]=basketball
)
echo "${#sport[@]}"
Por lo tanto, devolvemos el tamaño de la array usando el comando «${#sport[@]}», el # se usa para obtener el tamaño de la variable al lado, usando las comillas dobles se evalúa el valor del comando y obtenemos el número de elementos en la array como se desee.
Insertar un elemento en Array
Insertar un elemento es bastante sencillo, necesitamos establecer el índice apropiado del elemento seguido del valor del elemento que desea dar.
#!/bin/usr/env bash
declare -a sport=(
[0]=football
[1]=cricket
[2]=hockey
[3]=basketball
)
echo "${sport[@]}"
sport[4]="dodgeball"
sport[2]="golf"
echo "${sport[@]}"
Hemos agregado el quinto elemento (cuarto índice) a la array y también hemos modificado/editado el tercer elemento de la array (segundo índice). El arrayname[index]=value es todos los trucos para agregar, modificar o inicializar los elementos de la array.
También podemos agregar elementos a una array usando el operador +=.
#!/bin/usr/env bash
declare -a sport=(
[0]=football
[1]=cricket
[2]=hockey
[3]=basketball
)
echo "${sport[@]}"
sport+=("golf" "baseball")
echo "${sport[@]}"
echo "Size : ${#sport[@]}"
Como se ve en el ejemplo, podemos agregar múltiples elementos a la array con un código mínimo. Usamos array_name+=(elements) para agregar elementos a la array.
Eliminar un elemento de Array
Para eliminar un elemento de la array, podemos usar el comando unset. El comando toma el nombre de la variable en nuestro caso el nombre de la array y el índice de ese elemento. El índice también puede ser relativo, es decir, -1 indica el último elemento y -2 el penúltimo y así sucesivamente.
#!/bin/usr/env bash
declare -a sport=(
[0]=football
[1]=cricket
[2]=hockey
[3]=basketball
)
unset sport[1]
echo "${sport[@]}"
echo "${#sport[@]}"
Como podemos ver, unset arrayname[index] eliminará el elemento en el índice de la array. Además, el tamaño de la array se ha reducido de 4 a 3, lo que indica que el elemento se elimina por completo y no solo se reemplaza con espacios en blanco.
Uso de índices relativos
Si usamos índices como -1, -2, etc., los elementos se referencian desde el último elemento y, por lo tanto, también podemos eliminarlos o modificarlos con un orden relativo desde atrás.
#!/bin/usr/env bash
declare -a sport=(
[0]=football
[1]=cricket
[2]=hockey
[3]=basketball
)
unset sport[-3]
echo "${sport[@]}"
Como podemos ver, el índice 1 también se menciona como -3 desde atrás y, por lo tanto, se vuelve relativamente más fácil hacer referencia a ciertos elementos en una array grande.
Empalme una array
Podemos empalmar (sacar una poción) una array para asignarla o imprimirla en otra variable/array.
#!/bin/usr/env bash
declare -a sport
sport+=("football" "cricket" "hockey" "basketball")
sport+=("golf" "baseball")
echo "sport = ${sport[@]}"
arr="${sport[@]:1:3}"
echo "arr = ${arr[@]}"
Hemos sacado un trozo de la array deportiva, es decir, el elemento entre el índice 1 y el 3 inclusive, y lo hemos asignado a la variable arr, que también es una array. El operador @ obtiene todos los elementos de la array y luego podemos empalmar la array entre los índices 1 y 3 para que tengamos los elementos en 1, 2 y 3 (críquet, hockey y béisbol) de la array deportiva.
Defina una array estática e imprima los elementos de la array
#To declare static Array
programmingArray=(Java Python Ruby Perl)
#In below 2 ways we can print the elements of the static array
echo "Way 1 of printing static values by using <array>[@]:0 - " ${programmingarray[@]$
echo "Way 2 of printing static values by using <array>[*]:0 - " ${programmingarray[*]$
De 2 maneras podemos imprimir elementos de array estática
Ejecución del programa
sh <filename> So, we can give as sh arraycheck2.sh # arraycheck2.sh is the name of the script file here
Pasar los argumentos de la línea de comando en un archivo de script
#All the array elements are stored in an array called programmingArray
programmingArray=("$@")
#Index values start from 0
#If we do not specify the index, it will take up the size of first index value
echo "Size of programmingArray at 0th location..:" $(#programmingArray[0]}
echo "Size of programmingArray at 1st location..:" $(#programmingArray[1]}
El script anterior se puede ejecutar como
# Aquí Java, Python y Ruby son argumentos de línea de comando
sh arrayCheck.sh Java Python Ruby
Pasos de ejecución del script:
programaciónArray=(Java Python Ruby)
#Java estará presente en el índice 0, su tamaño se puede calcular de la siguiente manera
${#array de programación[0]}
De manera similar, Python estará presente en el primer índice, su tamaño se puede calcular de la siguiente manera
${#array de programación[1]}
Producción:
Iterando los valores de la array usando for loop
$@ dará todos los valores que se pasaron a través de argumentos de línea de comandos y se almacena en una array.
Se puede iterar usando el bucle «for»
declare -a programmingArray=("$@")
i=0
for programming in "$@"
do
echo "Array value at index " $i " : " $programming
i=$((i+1));
done
Producción:
Echemos un vistazo rápido a lo que representan todos y cada uno de los símbolos.
|
Sintaxis
|
Producción |
| arr=() |
arr[0]=3 Sobrescribir 1er elemento arr+=(4) Agregar valor(es) str=$(ls) Guarda la salida de ls como una string arr=( $(ls) ) Guarda la salida de ls como una array de archivos ${arr[@]:s:n} Recuperar n elementos comenzando en el índice |
|
#Podemos proporcionar un conjunto de valores como esto arr=(uno dos tres) |
Para inicializar una array |
| ${arr[0]} | Para recuperar el primer elemento. Siempre el índice comienza con 0 |
| ${arr[@]} | Para recuperar todos los elementos y luego podemos iterar en un bucle |
| ${!arr[@]} | Para recuperar índices de array solos |
| ${#array[@]} | Para calcular el tamaño de una array |
| array[2]=3 | Para sobrescribir el tercer elemento, debemos usarlo de esta manera. Como el índice comienza en 0, arr[2] es correcto. |
| arr+=(40) | Para agregar valores, podemos usar + y luego asignar con = y, por lo tanto, se usa +=. |
| str=$(ls) | Para guardar la salida del comando «ls» como una string (se muestra el Ejemplo 4 para esta salida) |
| arr=( $(ls) ) | Para guardar la salida «ls» como una array de archivos (se muestra el Ejemplo 5 para esta salida) |
| ${array[@]:s:n} | Para recuperar «n» elementos que comienzan en el índice «s» |