Cómo pasar y analizar argumentos y parámetros de secuencias de comandos Bash de Linux

Analizar y pasar argumentos a scripts de bash/scripts de shell es bastante similar a la forma en que pasamos argumentos a las funciones dentro de los scripts de Bash. Veremos el proceso real de pasar los argumentos a una secuencia de comandos y también veremos la forma de acceder a esos argumentos dentro de la secuencia de comandos.

Pasar argumentos antes de ejecutar

Podemos pasar parámetros justo después del nombre del script mientras ejecutamos el comando del intérprete bash. Puede pasar parámetros o argumentos al archivo. Solo el comando para ejecutar el script normalmente agregando el valor de los parámetros directamente al script. Cada parámetro es un valor separado por espacios para pasar al script de shell.

bash scriptname.sh 

El comando anterior simplemente ejecutará el script sin pasar los parámetros.

Mientras que el siguiente comando pasará los argumentos al script. 

bash scriptname.sh parameter1 parameter2 parameter3 nth-parameter

La captura de pantalla anterior muestra los parámetros pasados ​​al script, cómo lo haremos, lo cual explicaremos en la siguiente sección. Pero ahora podemos ver que hemos pasado los parámetros desde fuera del script usando variables de entorno de bash. Incluso puede usar strings y otros tipos de datos, pero tenga cuidado con los espacios en blanco. El espacio en blanco hará que la variable sea un parámetro separado. Por lo tanto, especialmente para las strings, tenga cuidado de rodearlas estrictamente con comillas.

Detección de argumentos de línea de comandos

Ahora, veremos cómo accedemos a esos parámetros dentro del script. Usaremos el número de parámetros pasados ​​en el orden, es decir, para los primeros parámetros pasados, analizaremos (accederemos) al parámetro usando $1 como variable. El primer parámetro se almacena en la variable $1. Además, puede asignar esta variable a cualquier otra variable definida por el usuario que desee. Para el enésimo parámetro pasado, puede usar $n para acceder a ese parámetro en particular. Aquí, el nombre de la variable comienza con 1 porque el nombre del archivo/script es el parámetro 0. Si tiene más de 9 parámetros, asegúrese de usar { } alrededor del número sin el paréntesis, bash solo verá $10 como $1 y excluirá el 0, así que use ${10} y así sucesivamente en lugar de simplemente $10.

#!/bin/bash

echo "1st parameter = $1 "
echo "2nd Parameter = $2 "

La secuencia de comandos anterior puede acceder a los parámetros desde la línea de comando/shell utilizando los parámetros posicionales, que son 1, 2, 3, etc. 

Como puede ver, hemos utilizado {} para acceder a los números de variable de parámetro desde 10 en adelante. El script se puede usar para bucles y bucles while para iterar sobre los parámetros, pero lo discutiremos en secciones posteriores. 

Asignar argumentos proporcionados a la variable Bash

También podemos asignarlo a otras variables personalizadas para dinamizar el script y moldearlo según las necesidades. Aunque el script anterior, cuando se ejecuta, solo imprimirá dos parámetros, seguramente puede acceder a más parámetros usando la variable como el orden de los parámetros en números. La secuencia de comandos puede acceder a las variables posicionales desde la línea de comando y usarlas en los lugares requeridos donde sea necesario dentro de la secuencia de comandos.

#!/bin/bash

a=$1
b=$2
p=$(($a*$b))
echo "The product of $a and $b = $p"

El script anterior accede a los parámetros posicionales, es decir, $1 y $2 pasados ​​al script y almacena las variables definidas por el usuario para acceder a ellas más tarde y modificarlas en consecuencia. También podemos acceder a más parámetros usando métodos iterativos como veremos en las próximas secciones.

También tenemos la capacidad de verificar cualquier parámetro NULL o vacío pasado usando las banderas -z o -n. A partir de esto, podemos verificar si los parámetros se pasaron o no.

#!/bin/bash

if [[ -z $1 ]];
then 
    echo "No parameter passed."
else
    echo "Parameter passed = $1"
fi

Con este script, podemos detectar si se pasó algún parámetro posicional o si no se pasó nada. El indicador -z comprueba si hay NULL o variables no inicializadas en BASH. El indicador -z devuelve verdadero si la variable pasada es NULL o no está inicializada. Por lo tanto, podemos hacer uso de sentencias If-else básicas para detectar los parámetros pasados. 

También podemos usar el indicador -n que devuelve verdadero si no se pasan parámetros, ¡así que tenemos que usar ! para revertir la condición.

Como sigue:

#!/bin/bash

if [[ ! -n $1 ]];
then 
    echo "No parameter passed."
else
    echo "Parameter passed = $1"
fi

Este script también dará el mismo resultado, pero estamos utilizando el indicador -n en lugar de -z.

Lectura de varios argumentos con bucle For o While

Podemos usar la variable «@» para acceder a cada parámetro pasado al script a través de la línea de comando. Es una variable especial que contiene la array de variables en BASH. En este caso, lo estamos usando solo, por lo que contiene la array de parámetros posicionales pasados. Podemos usarlo para iterar sobre los parámetros pasados ​​usando bucles o bucles while también.

#!/bin/bash

for i in $@
do 
        echo -e "$i\n"
done

Usamos un bucle for basado en rango para iterar hasta que haya elementos en la array @. Simplemente iteramos sobre la array e imprimimos el elemento. Simplemente podemos asignarlo, modificar los valores y realizar los cambios necesarios en los parámetros y argumentos para lograr el resultado deseado del script. 

O

También podemos imprimir los argumentos usando el ciclo while y las variables ambientales de BASH.

#!/bin/bash

i=$(($#-1))
while [ $i -ge 0 ];
do
    echo ${BASH_ARGV[$i]}
    i=$((i-1))
done

Estamos usando la variable ‘ # ‘ ya que contiene la cantidad de parámetros pasados. Inicializamos la cantidad de parámetros y quitamos uno, ya que vamos a usar una array para iterar sobre ella. Entonces, como de costumbre, el índice de la array comienza desde 0. Como esta array se inicializa desde el último elemento o parámetro pasado, necesitamos disminuir el contador hasta 0 para imprimir cada parámetro en el orden en que se pasan. Simplemente usamos la array BASH_ARGV para acceder a los parámetros e imprimir su valor. Además, en cada iteración, disminuimos el valor de i- el iterador o el contador en uno usando las llaves aritméticas dobles. A partir de esto, simplemente imprimimos cada parámetro pasado al script usando un ciclo while como se muestra en la captura de pantalla de salida. 

Lectura con nombres de parámetros

Uso de getopts para analizar argumentos y parámetros

Podemos usar el programa/comando getopts para analizar los argumentos pasados ​​al script en la línea de comando/terminal usando bucles y declaraciones de cambio de mayúsculas y minúsculas. 

#!/bin/bash

while getopts n:c: option
do 
    case "${option}"
        in
        n)nation=${OPTARG};;
        c)code=${OPTARG};;
    esac
done

echo "Nation : $nation"
echo "code   : $code"

Usando getopts, podemos asignar los argumentos/parámetros posicionales desde la línea de comando a las variables bash directamente. Esto nos permite administrar los parámetros de manera agradable y sistemática. En el script anterior, hemos usado dos argumentos para almacenar las variables de bash usando la sintaxis de getopts, bucles while y sentencias switch-case. 

Impresión de valores de todos los argumentos

Podemos imprimir los argumentos pasados ​​al script por una simple y poderosa variable ‘@’ que almacena todos los parámetros pasados. 

#!/bin/bash

echo "The arguments passed in are : $@"

Acceso al número de parámetros pasados

También podemos usar la variable ‘#’ para acceder al número de parámetros pasados ​​desde la línea de comandos. La variable # básicamente contiene el número de parámetros/argumentos que se pasan al script.

#!/bin/bash

echo "The number of arguments passed in are : $#"

Los siguientes fueron el proceso y la especificación de pasar y analizar las variables en el script bash. La lógica de desplazar y modificar las variables está en manos del usuario. Esta fue solo una demostración de pasar y analizar los argumentos de la línea de comando al script para hacerlos más dinámicos.