Cómo usar entradas en sus scripts de shell

"El programador perezoso reutilizará todo lo que pueda para realizar su trabajo. Esta virtud conduce a la reutilización del código al alentar a que el código se escriba solo una vez".

— Larry Wall, "Las tres virtudes de un programador"

Digamos que te cansas de escribir la misma secuencia de comandos y finalmente creas un buen script de shell para ejecutar cosas con menos pulsaciones de teclas. Pero a veces desea ejecutarlo con diferentes argumentos y definitivamente No quiero duplicar su gran guión. Necesita una forma de proporcionar y usar argumentos desde la línea de comandos. Este artículo cubre exactamente eso.

Entradas de secuencias de comandos de proceso

Los scripts de shell tienen acceso a algunas variables "mágicas" del entorno:

• $0 - El nombre del guión
• $1 - El primer argumento enviado al script
• $2 - El segundo argumento enviado al script
• $3 - El tercer argumento... y así sucesivamente
• $# - El número de argumentos proporcionados
• $@ - Una lista de todos los argumentos proporcionados

#!/bin/bash

if [ $# -eq 0 ];
then
  echo "$0: Missing arguments"
  exit 1
elif [ $# -gt 2 ];
then
  echo "$0: Too many arguments: $@"
  exit 1
else
  echo "We got some argument(s)"
  echo "==========================="
  echo "Number of arguments.: $#"
  echo "List of arguments...: $@"
  echo "Arg #1..............: $1"
  echo "Arg #2..............: $2"
  echo "==========================="
fi

echo "And then we do something with $1 $2"

Aquí hay algunos ejemplos de cómo ejecutar esto con diferentes combinaciones de argumentos:

$ ./ex01.sh 
./ex01.sh: Missing arguments

$ ./ex01.sh aa
We got some argument(s)
===========================
Number of arguments.: 1
List of arguments...: aa
Arg #1..............: aa
Arg #2..............: 
===========================
And then we do something with aa 

$ ./ex01.sh aa bb
We got some argument(s)
===========================
Number of arguments.: 2
List of arguments...: aa bb
Arg #1..............: aa
Arg #2..............: bb
===========================
And then we do something with aa bb

$ ./ex01.sh aa bb cc
./ex01.sh: Too many arguments: aa bb cc

Esto está bien si tienes uno o dos argumentos. Sin embargo, observe que el separador predeterminado entre argumentos es el carácter de espacio. Y debido a que Space es el separador predeterminado para los argumentos, pueden suceder cosas interesantes. Por ejemplo, esto es lo que sucede si usa comillas con más de dos argumentos:

$ ./ex01.sh aa "bb cc xx yy zz"
We got some argument(s)
===========================
Number of arguments.: 2
List of arguments...: aa bb cc xx yy zz
Arg #1..............: aa
Arg #2..............: bb cc xx yy zz
===========================
And then we do something with aa bb cc xx yy zz

Observe que el script interpreta bb cc xx yy zz como uno argumento porque los valores están encerrados entre comillas dobles, lo cual también está bien si esto es lo que desea.

[ Mantenga sus comandos de Linux a mano. Descargue la hoja de trucos de los comandos avanzados de Linux. ]

Otra cosa interesante es cuando su secuencia de comandos obtiene argumentos de variables . Si la variable contiene espacios, debe decidir si quiere eso valor para ser tratado como un solo argumento o todas las partes para ser tratadas como diferentes argumentos:

$ export AUTHOR="John Lennon"

$ export SONG="Imagine"

$ ./ex01.sh $AUTHOR $SONG
./ex01.sh: Too many arguments: John Lennon Imagine

$ ./ex01.sh "$AUTHOR" "$SONG"
We got some argument(s)
===========================
Number of arguments.: 2
List of arguments...: John Lennon Imagine
Arg #1..............: John Lennon
Arg #2..............: Imagine
===========================
And then we do something with John Lennon Imagine

Cuando envía los argumentos como variables sin comillas, el script los interpreta todos como palabras separadas y "ve" tres argumentos:John , Lennon y Imagina .

Uso de comillas alrededor las variables hicieron que el script recibiera cada variable como un argumento, lo que tiene más sentido en este caso.

Manejar muchos más argumentos

Como viste, la variable mágica $@ contiene la lista de todos los argumentos recibidos por el script. Puede usar un bucle para procesar todos los argumentos:

#!/bin/bash

echo "We received $# argument(s)"

for i in "$@"
do
  echo "Arg...: $i"
done

Lo que te da esto:

$ ./ex02.sh a b c e "stuff with spaces"
We received 5 argument(s)
Arg...: a
Arg...: b
Arg...: c
Arg...: e
Arg...: stuff with spaces

Sé inteligente siendo perezoso

Lo importante cuando se trata de argumentos en sus scripts de shell es tener una comprensión clara de:

• ¿Qué forma puede tomar el contenido de un argumento?
  • Si se proporciona como una variable, ¿qué puso el "remitente" en esa variable para usted?
  • Si lo proporciona la entrada del usuario, ¿cómo puede asegurarse de que el usuario no "rompa" su lógica?
• ¿Qué argumentos son aceptables u obligatorios para su ¿texto?
  • ¿Qué quiere hacer si los argumentos no son válidos? El script podría arrojar un error o quizás usar valores predeterminados.

Espero que esto te ayude a seguir siendo flojo de la manera correcta... mejorando o reutilizando algunos de tus scripts.