You don't have access to this class

Keep learning! Join and start boosting your career

Aprovecha el precio especial y haz tu profesión a prueba de IA

Antes: $249

Currency
$209
Suscríbete

Termina en:

0 Días
6 Hrs
0 Min
32 Seg
Curso de Programación en Bash Shell

Curso de Programación en Bash Shell

Marco Antonio Toscano Freire

Marco Antonio Toscano Freire

Paso de parámetros y opciones

15/43
Resources

How to handle options and parameters in a Bash script?

In this class we approach the interesting world of handling options and parameters within Bash scripts. For those looking to improve their scripting skills, mastering these concepts is essential. We explore how to send options independently or in addition to each other and how to read their values depending on the method of sending.

What considerations should we take into account?

When working with scripts, it is crucial to keep the following considerations in mind:

  • Independent or complementary sending: options can be sent independently or together with parameters. It is essential to understand how to handle both.
  • Method of reading values: The way values are read will change depending on the type of dispatch.

How do we exemplify the use of options and parameters?

Let's create a script on an Ubuntu server to illustrate these concepts. Let's go step by step:

  1. Copying a previous script: We start by duplicating an existing script to create a new one called options.sh. We use the following command to copy:

    cp script8.sh 9-options.sh
  2. Editing the script: When we open the new file, we update the description to reflect the exercise of sending options with or without parameters. Delete unneeded lines by pressing DD (to delete lines in vi).

  3. Creating a sample program: Add a title to the script and list the options entered. We use the echo command to print text:

    echo "Program options"echo "Option 1 sent: $1"echo "Option 2 sent: $2"echo "Options sent: $*"

How do we retrieve submitted values?

To handle and retrieve option and parameter values, it is essential to use a while loop in combination with a case. The while helps determine whether the argument is an option or a parameter. Let's see an example:

while [ -n "$1" ]; do case "$1" in -a) echo "-a option used" ;; -b) echo "-b option used" ;; -c) echo "-c option used" ;; *) echo "$1 is not an option" ;; esac shiftdone.

What results can we expect when running the script?

When executing the script and sending the arguments, the program will distinguish between options and parameters. For example:

./9-options.sh argument1 argument2 -a

The result will show:

  • Option 1 sent: argument1
  • Option 2 sent: argument2
  • Options sent: argument1 argument2 -a
  • -a option used

It is vital to note that the option is recognized because of the - (hyphen) prefix, differentiating an option from a parameter.

Knowledge of how to correctly handle options and parameters in Bash scripts will allow you to run specific processes and manipulate data efficiently. This is just a first glimpse, but once you master these concepts, your scripts will gain versatility and flexibility. Keep practicing and exploring!

Contributions 49

Questions 3

Sort by:

Want to see more contributions, questions and answers from the community?

No entendí esta clase.

Sinceramente el curso esta muy bueno, pero está clase está mal. Paso directamente a bucles sin explicar primero la sintaxis de los condicionales y bucles.

Comparaciones De Cadenas Alfanumericas

Operador Verdad (TRUE) si:

cadena1 = cadena2 cadena1 es igual a cadena2
cadena1 != cadena2 cadena1 no es igual a cadena2
cadena1 < cadena2 cadena1 es menor que cadena2
cadena1 > cadena 2 cadena1 es mayor que cadena 2
-n cadena1 cadena1 no es igual al valor nulo (longitud mayorque 0)
-z cadena1 cadena1 tiene un valor nulo (longitud 0)

Comparacion De Valores Numericos

Operador Verdad (TRUE) si:

x -lt y x menor que y
x -le y x menor o igual que y
x -eq y x igual que y
x -ge y x mayor o igual que y
x -gt y x mayor que y
x -ne y x no igual que y

Comprobacion De Atributos De Fichero

Operador Verdad (TRUE) si:

-d fichero fichero existe y es un directorio
-e fichero fichero existe
-f fichero fichero existe y es un fichero regular (no un
directorio, u otro tipo de fichero especial)

-r fichero Tienes permiso de lectura en fichero
-s fichero fichero existe y no esta vacio
-w fichero Tienes permiso de escritura en fichero
-x fichero Tienes permiso de ejecucion en fichero (o de busqueda
si es un directorio)

-O fichero Eres el dueño del fichero
-G fichero El grupo del fichero es igual al tuyo.

fichero1 -nt fichero2 fichero1 es mas reciente que fichero2
fichero1 -ot fichero2 fichero1 es mas antiguo que fichero2

Debe cambiar ese color azul del bash no veo que pone

Estas son las opciones mas utilizadas para los script de bash
-a Listar todos los elementos.
-c Obtener la cantidad de elementos.
-d Directorio de salida.
-e Expandir elementos.
-f Especificar un archivo.
-h Mostrar la página de ayuda.
-i Ignorar mayúsculas.
-l listar un texto.
-n Decir que no a una pregunta.
-o Para enviar la salida a un archivo o más.
-q No preguntar al usuario.
-r Procesar algo recursivamente.
-s Modo sigiloso.
-v Modo detallado.
-x Especificar el ejecutable.
-y Decir sí sin preguntar al usuario.
info de https://likegeeks.com/es/scripting-de-bash-parametros-y-opciones/

Yo revisaria este video porque quedo muy mal explicado. Creo que confunde mas de lo que enseña ademas que tiene errores. Me quede buscando ese $! como loco

min 4:32. Que significa el parámetro -n en el ciclo while?

Sugerencia al profesor, cambiar los colores de la consola, en ocasiones cuesta mucho leer los comandos que escribe.

Opciones y parametros

Antes se toco el tema de los argumentos, y así se quedo para que se entendiera, pero se tiene que mencionar que un argumento cae dentro de una de las dos siguientes categorías.

  • Options(Opciones). este argumento modifica el comportamiento del comando, pues lo utiliza ya sea para saber que se va a proceder, de hecho estos argumentos fueron los primeros que utilizamos desde el inicio por ejemplo al enlistar el contenido del directorio actual, incluso aquello archivos ocultos.

    ls -a
    

    La a en este comando es un argumento tipo opcion, y como resultado modifico su comportamiento y nos otorgo un output distinto, las opciones se destacan por tener el prefijo -.

  • Params (Parametros). Estos argumentos son datos que nuestro comando utilizara o que alguna opcion utilizara, en su proceso, no modifican el comportamiento.

#!/usr/bin/env bash
#lec_9_file.sh
echo "Inputs:"
echo "parameter 1: $1 , parameter 2: $2, parameter 3: $3, parameter 4: $4 all : $*"
echo "Checking values:"
while [[ -n "$1" ]] #while exit options
do case $1 in #chose a case
  -a)
    echo "$1 : it is the -a option"
    #exit
    ;;
  -b)
    echo "$1 : It is the -b option"
    #exit
    ;;
  -c)
    echo "$1 : It is the -c option"
    #exit
    ;;
  *)
    echo "$1 : is not an option"
    #exit
    ;;
esac; shift; done
#  bash lec_9_file.sh  -a -b -f -g

Esta clase debería estar mejor explicada

No me quedo clara esta clase.

Se me complica dos cosas en este video, el español del profesor y el codigo. El profe se ve que tiene mucho conocimiento pero no sé me cuesta entenderle 😦

Muchas gracias por el esfuerzo, pero a esta clase le faltó mucho contexto la verdad.

El -n es una prueba para verificar si el string está vacío.
Si el $1 está vacío o ya evaluó el último argumento de este string, el bucle no se ejecutará nuevamente.
Fuente de consulta

Por otra parte entiendo que:

  1. Todos los argumentos pasados son parámetros.
  2. Solo los argumentos precedidos con el guíon - son opciones. Y éstas pueden ser evaluadas en un case.

Último aporte:

  • shift indica que se evalúe el siguiente parámetro del array recorrido en el while (un string en este caso). Además de evaluar el siguiente, elimina el evaluado en el ciclo anterior. Cuando se elimine el último argumento y el string esté vacío, va a salir del bucle.
    Fuente consultada
  • esac indica el fin del case
  • done indica el fin del while
  • $! no imprime nada porque es un error. En realidad el profesor quiso escribir $1

Tenemos que tener en cuenta que :
shift lo que hace es eliminar $1 y pasa $2 a ser $1,
la siguiente vez, elimina $2 y pasa $3 a $1, y así sucesivamente
Y también tenemos que tener en cuenta que
[ -n “$1” ] el -n implica que es cierto mientras $1 no sea ni vacío ni nulo, es decir mientras exista y sea distinto de vacío.

# !/bin/bash
# Programa paso de opciones con o sin parámetros
# Autor: JRPF - Dic - 2022

clear
echo -e "\nPrograma opciones"
echo -e "Opción 1 enviada : $1"
echo -e "Opción 2 enviada : $2"
echo -e "Opciones enviadas: $*"
echo -e "\n"
echo -e "\nRecuperar valores"
i=0
while [ -n "$1" ]
do
        (( i +=1 ))
        case "$1" in
                -a) echo "$i -> -a option utilizada";;
                -b) echo "$i -> -b option utilizada";;
                -c) echo "$i -> -b c option utilizada";;
                *) echo "$i -> $1 no es una opción válida";;
        esac
        shift
done

En el while case *) el profe puso “$!” y es “$1”

hola buenos días
tengo una pregunta : si yo quiero hacer que mi script se ejecute automáticamente ,por ejemplo al arrancar mi servidor remoto, que se debe hacer , tal vez con un daemon , quien sabe de esto por favor,
gracias

*) echo “$1 no es una opcion”;;

Muestra:
Algo no es una opcion
Mas no es una opcion
-a option utilizada

lo más recomendado para gestionar las opciones y argumentos en un script de BASH es utilizar getopts.

Prefiero usar argparse-bash.

Si bien, implica una dependencia a Python, es mucho más robusto y poderoso que manejar a mano una interfaz de línea de comandos.

Ejemplo sacado del proyecto:

#!/usr/bin/env bash

ARGPARSE_DESCRIPTION="Sample script description"      # this is optional
source $(dirname $0)/argparse.bash || exit 1
argparse "$@" <<EOF || exit 1
parser.add_argument('infile')
parser.add_argument('outfile')
parser.add_argument('-a', '--the-answer', default=42, type=int,
                    help='Pick a number [default %(default)s]')
parser.add_argument('-d', '--do-the-thing', action='store_true',
                    default=False, help='store a boolean [default %(default)s]')
parser.add_argument('-m', '--multiple', nargs='+',
                    help='multiple values allowed')
EOF

echo required infile: "$INFILE"
echo required outfile: "$OUTFILE"
echo the answer: "$THE_ANSWER"
echo -n do the thing?
if [[ $DO_THE_THING ]]; then
    echo " yes, do it"
else
    echo " no, do not do it"
fi
echo -n "arg with multiple values: "
for a in "${MULTIPLE[@]}"; do
    echo -n "[$a] "
done
echo

En el minuto 5:40, dices que escribimos un “asterisco” en caso de que sea “asterisco”…porque el usuario ingresaría un “asterisco”?.. en fin, por definición del “case” el " * " se coloca como ultima opción por si acaso de que el usuario ingrese cualquier otra opción que no sea alguna de las que le asignamos.

Parámetros: Cualquier valor que se pasa a un script o comando. Puede ser un archivo, un número, un texto, etc. Opciones: Parámetro especial que empieza con "-" (guion simple) o "--" (doble guion) y generalmente activa o desactiva una funcionalidad en un comando. A lo que entendí, un parámetro se ingresa para trabajar con el como dato de entrada, y la opción es para configurar las funciones del comando, dado que, aunque se pueden utilizar solo parámetros para todo, el diferenciar las opciones con - ó -- hace más claro, flexible y facil de organizar la escritura de los comandos según lo que se necesite, por ejemplo: `./backup.sh full /ruta/destino ahora` puede entenderse más claro como: `./backup.sh --mode full --path /ruta/destino --time ahora`
2 comentarios en código para entender mejor la clase: `#!/bin/bash` `# Programa para ejemplificar como se realiza el paso de opciones con o sin parámetros ` `# Autor: Miguel Reyes <[email protected]>` `echo "Programa Opciones"` `echo "Opción 1 enviada: $1"` `echo "Opción 2 enviada: $2"` `echo "Opciones enviadas: $*"` `echo -e "\n"` `echo "Recuperar valores"` `while [ -n "$1" ] # Asegurarse de que hay argumentos` `do` ` ``case "$1" in` ` `` ``-a) echo "-a opción utilizada";;` ` `` ``-b) echo "-b opción utilizada";;` ` `` ``-c) echo "-c opción utilizada";;` ` `` ``*) echo "$1 no es una opción";;` ` ``esac` ` ``shift # Avanza al siguiente argumento` `done`
En verdad me ha costado tomar este curso, entiendo la intencion y el profesor se nota que sabe muchisimo, pero creo que no es de los que enseñan. Se siente apresurado, sin contexto y no explica bien, raro ver esto en platzi, a parte son 43 clases que se me hacen eternas :S
Muy flojo este curso. Escribe el codigo y no explica, no dice que son los parametros ni las opciones, no explica para que sirven, si tiene que utilizar un while para esta explicacion que primero lo explique. Ni hablar los colores de la pantalla que no se ve absolutamente nada
Muy recomendado para entender mejor el bash scripting: <https://www.youtube.com/watch?v=np-8ivtLRwI&list=PLDbrnXa6SAzX9kqtPWlzV3DPIGCXVr7fQ&index=1&ab_channel=dfbastidas>
Para que puedan entender el significado de `-n` y de otros operadores para expresiones condicionales les dejo el siguiente comando `help test` .
Muy mala la paleta de colores usadas en Vim, realmente en muchas ocasiones dificulta la lectura.

Los parámetros y las opciones parecen similares a primera vista, pero tienen propósitos diferentes.
Imaginemos los comandos tipos como ls o rm.
Cuando ejecutamos

# caso 1
ls -l
# caso 2
ls -l 1_utilityPostrgress.sh

En el caso 1, Le estamos enviando una opción "-l" al comando ls, este comando se encargará de interpretar el significado y nos dará su respuesta (listar todos los archivos del directorio con sus permisos, etc)

En el caso 2, no solo le estamos enviando una opción, sino que también le estamos pasando un parámetro (1_utilityPostrgress.sh), en este caso, nuevamente el comando se encargara de interpretar la opción “-l” pero también deberá actuar conforme los parámetros que le enviamos (el 1_utilityPostrgress.sh).

El comando es el mismo en ambos casos (ls) pero las opciones y los parámetros que le enviamos hacen que tengan una salida u otra.

Ahora, ¿cómo implemento esto en mi script?
Pues depende de tu caso, por ejemplo, si el usuario envía como parámetro -y podrías hacer que algunas variables tomen un valor por defecto
ps: esto es lo que hace npm cuando ejecutamos

npm init -y
  • Envío opciones / Parámetros
  1. Opciones VS. Parámetros
  2. Envío independiente
  3. Envío complementario
  4. Leer los valores

Para entender a la perfección esta clase continúa el curso hasta la case 27, luego regresa y todo tendrá sentido. El único concepto que no se explicó hasta ese momento del curso es la palabra reservada:

shift

Dado el siguiente conjunto de “operandos”, es decir, los valores ubicados luego del nombre del script, como:

$ ./mi_script.sh "lorem" "ipsum" "dolor"

Como ya sabes, bash representa de forma ordenada cada valor con el identificador $N ($1, $2, $3, así sucesivamente), la keyword shift recorre cada valor una posición hacia la izquierda. Entonces, del conjunto de operandos anterior, ahora Bash representaría al identificador $1 con el valor “ipsum”, y no con “lorem”, como sucedía antes de ejecutar a shift. Cada vez que esta keyword es leída por bash, este comportamiento vuelve a suceder, por lo que es completamente factible recorrer el conjunto completo de operandos llamando solo a la primera posición del conjunto, es decir, $1.

Hola, no estoy seguro de haber entendido muy bien esta clase, casi no se ve bien la terminal. Saludos!!

Es cierto que no explico nada, seguramente lo explique mas adelante

Creo que lo que hizo la “magia” fue el case, porque independientemente de si fuese una “opción” o un “parámetro”, el trabajo del script va a ser igual para ambas cosas. Quizás esto se pueda llevar a cabo de una forma más sofisticada, esto parece algo más lógico.
Saludos.

Entendido, algo confuso.

#!/bin/bash
# Paso de parametros y opciones

echo "Programa Opciones"
echo "Opción 1 enviada: $1"
echo "Opción 2 enviada: $2"
echo "Opciones enviadas: $*"
echo -e "\n"
echo "Recuperar los valores"
while [ -n "$1" ]
do
case "$1" in
-a) echo "-a opcion utilizada.";;
-b) echo "-b opcion utilizada.";;
-c) echo "-c opcion utilizada.";;
*) echo "$! no es una opcion.";;
esac
shift
done

genial

me costo un poco entender esta clase, pero la idea aca es pode hacer sripts con opciones como --hacer-algo --hacer-otra cosa

Entonces lo que logra con el while es checkear si vienen o no esos parámetros recorriendolos todos

El problema con el metodo enseñado anteriormente usando $1, $2, etc… causaría que llamado

--hacer-algo --hacer-otra cosa

--hacer-otra cosa --hacer-algo

en el primer caso $1 es una cosa, y en el segund otra

En esta clase se ven las opciones, las cuales son las instrucciones que acompañan a los comandos, por ejemplo:

ls -a

en el comando ls se usa la opción -a.

NOTA:
En el WHILE, se usa la opción -n $1, la cual quiere decir:
Mientras exista argumento en $1 haz…

Esto es porque se usa el comando SHIFT, el cual elimina el argumento que esté guardado en $1, volviendo a enumerar los argumentos desde $1 hasta $(n-1), siendo n el número de agumentos.

El mio quedó de la siguiente forma:
#! /bin/bash

<h1>Programa para ejemplificar como se realiza el paso de opciones con o sin parametros</h1> <h1>Autor: Jose Suarez</h1>

echo "Programa Opciones"
echo "Opcion 1 enviada: $1"
echo "Opcion 2 enviada: $2"
echo "Opciones enviadas: $*"
echo -e "\n"
echo “Recuperar los valores”

while [ -n “$1” ]
do
case “$1” in
-a) echo “-a opcion utilizada”;;
-b) echo “-b opcion utilizada”;;
-c) echo “-c opcion utilizada”;;
*) echo “$! no es una opcion”;;
esac
shift
done

Se debe explicar mejor las sentencias de if, while y for

La salida fue:

El comando `shift` en Bash se utiliza para desplazar los parámetros posicionales de un script o función hacia la izquierda. Esto significa que, después de ejecutar `shift`, `$1` se convierte en `$2`, `$2` en `$3`, y así sucesivamente. Esto es útil cuando deseas procesar los argumentos de un script uno por uno, eliminando el primero después de haberlo utilizado. Por ejemplo, si tienes un script que recibe múltiples parámetros y deseas iterar sobre ellos, `shift` facilita el manejo de estos parámetros al permitirte recorrerlos sin necesidad de manipular las variables directamente.

Esperare a las siguientes clases para entenderlo porque lo reitio muchas veces y no me quedo muy claro

Hola, Creo que entendí la clase.
Mas allá del la sintaxis del while y del case, que seguro profundiza mas a delante en el curso, explica como diferenciar los parámetros de las opciones al momento de definir como van a ser pasados al script y como son tratados en la lógica interna del mismo.
En este caso “Algo” y “Mas” son parámetros, mientras que “-a” es una opción, tal y como exiten opciones en comandos como "ls -l" o el mismo “python –version”.
Espero haber sido de ayuda.

# !/bin/bash
# Programa para ejemplificar como se realiza el paso de opciones con, sin parametro
# Author: Nelson Sanchez git @AnthonySnk

echo "Programa Opciones"
echo "Opcion [1] enviada: $1"
echo "Opcion [2] enviada: $2"
echo "Opciones enviadas: $*"
echo -e "\n"
echo "Recuperar Valores"
while [ -n "$1" ]
do
        case "$1" in
                -a) echo "-a option utilizada";; # mensaje para -a option
                -b) echo "-b option utilizada";; # mensaje para -b option
                -c) echo "-c option utilizada";; # mensaje para -c option
                 *) echo "Option no valida";; # mensaje para otra option
                --)
                        shift # The double dash which separates options from parameters
                        break
                        ;; # Exit the loop using break command
        esac
        shift
done
# ! /bin/bash
# Programa para ejemplificar como se realiza el paso de opciones con sin parámetros
# Autor: Martin Davila 


echo "Programa Opciones"
echo "Opción 1 enviada: $1"
echo "Opción 2 enviada: $2"
echo "Opción enviadas: $*"
echo -e "\n"
echo "Recuperar valores"
while [ -n "$1" ]
do
case "$1" in
-a) echo "-a option utilizada";;
-b) echo "-b option utilizada";;
-c) echo "-c option utlizada";;
*) echo "$! no es una opción";;
esac
shift
done```