Scripts Bash con argumentos: $1, $2, ${10}, $# y $*

Clase 8 de 43 • Curso de Programación en Bash Shell

Resumen

Domina la ejecución de scripts Bash con argumentos y usa con seguridad las variables especiales para recuperar el nombre del programa, contar parámetros y listarlos. Aquí verás cómo mapear argumentos a variables, cuándo usar comillas y cómo ejecutar paso a paso en Ubuntu, tal como se mostró en el ejemplo.

¿Qué son los argumentos en Bash y para qué sirven?

Los argumentos permiten pasar datos a un programa al momento de ejecutarlo. En Bash, se accede a cada argumento con $1, $2, … y, si hay más de nueve, con ${10}, ${11}, …. También puedes obtener el nombre del script con $0, conocer cuántos argumentos llegaron con $# y ver todos los argumentos con $*.

$0: nombre del script invocado.
$1, $2…$9: argumentos del 1 al 9.
${10}: argumento 10 en adelante.
$#: cantidad total de argumentos.
$*: todos los argumentos en una sola cadena.

¿Cómo se usan las variables especiales $0, $1, ${10}, $# y $*?

La referencia a cada argumento es directa. Por ejemplo, el primer argumento se asigna con $1 a una variable y el segundo con $2. Luego, puedes imprimirlos con echo. Para conocer cuántos llegaron, usa $#; para mostrarlos todos, $*.

Asignar el primer argumento: variable="$1".
Asignar el segundo argumento: variable="$2".
Contar argumentos: $# imprime la cantidad enviada.
Listar todos: $* devuelve la lista en una sola expansión.

¿Cómo referenciar del argumento 10 en adelante?

A partir del argumento 10 debes usar llaves para evitar ambigüedad.

Usar ${10} y no $10.
Aplicar lo mismo para ${11}, ${12}, etc.

¿Cuándo poner comillas en los argumentos?

Cuando el argumento tiene espacios, envuélvelo entre comillas para que Bash lo trate como un solo valor.

Ejemplo: "Programación Bash" es un único argumento.
Sin comillas, se dividiría en varios argumentos.

¿Cómo crear y ejecutar un script que reciba argumentos?

El flujo mostrado fue: crear el archivo, definir la cabecera de Bash, declarar variables a partir de $1 y $2, imprimir con echo, guardar, dar permisos de ejecución (+x) y ejecutar con ./ seguido de los argumentos.

¿Qué estructura mínima tiene el script de ejemplo?

#!/bin/bash
# Nombre: argumentos.sh
# Descripción: ejemplo del paso de argumentos.

nombre_curso="$1"
horario_curso="$2"

echo "El nombre del curso es: $nombre_curso, dictado en el horario de: $horario_curso"
echo "El número de parámetros enviados es: $#"
echo "Los parámetros enviados son: $*"

Guardar y salir: :wq.
Dar permisos de ejecución: aplicar +x al archivo.
Ejecutar: ./argumentos.sh "Programación Bash" "seis a ocho".

¿Quieres que revisemos más patrones de uso con $# y $ o casos con más de nueve argumentos usando ${10}*? Deja tu pregunta y ejemplo en los comentarios.

Alan Onofre Machorro

student•

Tengo este script, para complementar, que muestra como funcionan los carácteres especiales de los que habla el profe y otros mas. Mi script utiliza Firefox para ejemplificar el último proceso en segundo plano, pueden cambiarlo por otro programa para que lo vean funcionar :)

#!/bin/bash 
#
#Ejecución: $ ./parametros.sh argumento1 argumento2 argumento3
#Cuantos argumentos se deseen
#By Dex

 
# Muestra el nombre del script 
printf "\nPARÁMETRO ESPECIAL \$0\n"
echo "El nombre del script es: $0" 

# Muestra el número de parametros
printf "\nPARÁMETRO ESPECIAL \$#\n" 
echo "Hay $# parámetros" 

# Lista de parámetros (en un solo argumento) 
printf "\nPARÁMETRO ESPECIAL \$*\n"
echo "Parámetros (un solo argumento) : $*" 


# Lista de parámetros (un parámetro por argumento) 
printf "\nPARÁMETRO ESPECIAL \$@\n"
echo "Parámetros (un parámetro por argumento) :" 
for param in $@
do 
echo "$param" 
done 

# Muestra el PID del script 
printf "\nPARÁMETRO ESPECIAL \$$\n"
echo "El PID del script ejecutado es: $$" 

# Creamos un proceso en segundo plano 
printf "\nPARÁMETRO ESPECIAL \$!\n"
echo "Abriendo Firefox en segundo plano . . ."
firefox & 

# Muestra el PID del proceso ejecutado en segundo plano 
echo "El PID de Firefox ejecutandose en segundo plano es: $!" 

# Muestra el código de retorno del último comando, en este caso "echo" 
printf "\nPARÁMETRO ESPECIAL \$?\n"
echo "El código de retorno del comando es: $?" 

# Generamos un error para ejemplificar el cas
echo "Generando un error . . ." 
lss -l

# Muestra el código de retorno del último comando 
echo "El código de retorno del comando erróneo es: $?"

Edinson Padrón

student•

Gran trabajo. Me haz ahorrado ver el video.

Unas pequeñas sugerencias aquí y allá:

#!/bin/bash 

#Ejecución: $ ./parametros.sh argumento1 argumento2 argumento3
#Cuantos argumentos se deseen
#By Dex

 
# Muestra el nombre del script 
printf "\nPARÁMETRO ESPECIAL \$0\n"
echo "El nombre del script es: $0" 

# Muestra el número de parametros
printf "\nPARÁMETRO ESPECIAL \$#\n" 
echo "Hay $# parámetros" 

# Lista de parámetros (en un solo argumento) 
printf "\nPARÁMETRO ESPECIAL \$*\n"
echo "Parámetros (un solo argumento) : $*" 

# Lista de parámetros (un parámetro por argumento) 
printf "\nPARÁMETRO ESPECIAL \$@\n"
echo "Parámetros (un parámetro por argumento) :" 
for param in $@; do 
  echo "$param" 
done 

# Muestra el PID del script 
printf "\nPARÁMETRO ESPECIAL \$$\n"
echo "El PID del script ejecutado es: $$" 

# Creamos un proceso en segundo plano 
printf "\nPARÁMETRO ESPECIAL \$!\n"
echo "Ejecutando el comando 'sleep' ejecución en segundo plano..."
sleep 10 & 

# Muestra el PID del proceso ejecutado en segundo plano 
echo "El PID del comando 'sleep' en segundo plano es: $!" 

# Muestra el código de retorno del último comando, en este caso "echo " 
printf "\nPARÁMETRO ESPECIAL \$?\n"
echo "El código de retorno del comando es: $?" 

# Generamos un error para ejemplificar el cas
echo "Generando un error..." 
lss -l

# Muestra el código de retorno del último comando 
echo "El código de retorno del comando erróneo es: $?"

Fredy Mendoza Vargas

student•

Excelente aporte

Junior Cupe Casquina

student•

#!/usr/bin/env bash
#lec_4_file
#Executing scripts with arguments

# $0 //tp get the name of the script
# $1 $(10) //tp get the arguments
# $# //to count arguments
# $* to print all the arguments

courseName=$1 #//first argument to courseName
courseTimetable=$2

echo "parameters:"
echo "courseName:$courseName"
echo "courseShip:$courseTimetable"

echo "parameters number:$#"
echo "list parameters:$*"

#to execute use:
# bash lec_4_file.sh "name course" "18:00 to 20:00" "OTHER_I" "OTHER_II"

Jordan Ronaldo Buitrago Sandoval

student•

the father of argc & argv

Irving Juárez

student•

Literal, solo que aqui no se cuantos argumentos sean como maximo, talvez hasta mil

Enzo Venturi

student•

@Irvingjuarez Intente:

getconf ARG_MAX

Edison Renato Valdez Vega

student•

$0 = Nombre del Script
$1 al ${10} = El numero de argumento. Si es mas de un dígito se pone entre llaves.
$# = Contador de argumentos
$* = Refiere a todos los argumentos

Irving Juárez

student•

Correcto

Enzo Venturi

student•

En vez de:

$~ bash sample.sh "Hey" "Gopher"

Intentar:

$~ bash sample.sh {"Hey","Gopher"}

KEVIN FIGUEROA

student•

Erick Armando Sánchez Flores

student•

¿Cómo haces esas capturas? :) se ve cool

Jesanchez

student•

Hola Kevin!!

nos podrias indicar como hiciste ese video?

Gracias

Andriy Tsushko

student•

Era tan dificil escoger un terminal que se vean bien las variables en vez de este espacio negro?Es desagradable seguir el curso con esta interfaz tan mala.

Ivan Rene Acosta Lallemand

student•

Amigo así es que vas a trabajar en Linux, el que se meta con eso no creo que le importe mucho si se ve bonito o no

daniel alonso

student•

Completamente de acuerdo. Lo mínimo que hubieran hecho sería cambiar la tipografía y el tamaño de letra. Estoy de acuerdo que así lo vas a ver cuando trabajes, pero para el curso es necesario hacer esos ajuste y evitar hacer el esfuerzo de tratar de ver lo que escribe, sobre todo porque no se aprovecha el espacio.

Dimas Antonio Mendoza Lozano

student•

Hola Muchachos, Como yo no entendi muy bien esta parte me puse a mirar bien como es el tema de los parametros. Les adjuntos dos imagenes, la primera es el codigo bash para la ejecucion del script, la segunda es el resultado del codigo. En esta ultima aclaro como se pasan los parametros. Si alguien no entiend me dice...

Josue Israel Rojas Vilca

student•

# !/bin/bash
# Programa para ejemplificar el paso de argumentos

nombreCurso=$1
horarioCurso=$2
echo "El nombre del curso es: $nombreCurso dictado en el horario de $horarioCurso"
echo "El numero de parametros enviados es: $#"
echo "Los parametros enviados son: $*"

Oscar Unzueta Salazar

student•

Los colores de la terminal con vim son horrorosos, el azul oscuro sobre fondo negro no se ve nada.

Reinaldo Mendoza

student•

de acuerdo

Marvin Javier Santos Fernández

student•

Miguel Ramírez

student•

Carlos Contreras

student•

Por que al $ le dice signo de sucre?

Gabriel Herz

student•

porque esa era la moneda que había en ecuador, dólar, sucre, pesos, como gustes.

Carmen Deni Martinez Gomez

student•

Tengo el siguiente codigo:

 # ! /bin/bash
consentida_uno=$1
consentida_dos=$2

echo "los perritos consentidos son $consentida_uno y $consendida_dos "
echo "el numero de parametros enviados es $# "```
pero el output es:
Business Intelligence$ ./3_pasarVariables.sh "papita" "pepe"
los perritos consentidos son papita y
el numero de parametros enviados es 2
¿que estoy haciendo mal?

Héctor Eduardo López Carballo

student•

Hola!

En el echo escribiste consendida en lugar de consentida.

Andres Prieto

student•

¿Esos comandos que usando "--" son argumentos?

Carlos Eduardo Gomez García

teacher•

¡Sí! Los puedes encontrar con varios nombres como "flags", "banderas", "parámetros", "argumentos" etc. Pero básicamente son unos modificadores para el comando que estés usando en cuestión :D

Andres Prieto

student•

@RetaxMaster Los flags para programarlas ¿Como sería?

Irving Juárez

student•

Bash funciona con numeros, pero los humanos funcionamos con palabras. Como se que estoy mandando los argumentos en el orden correcto? Creo que es muy facil llegar a confundirse en ese aspecto, aunque claro, supongo que la solución sencilla seria poner un comentario en el script acerca de como correrlo correctamente

Mario Alexander Vargas Celis

student•

En Bash, un script puede recibir argumentos que se pasan al ejecutar el script desde la línea de comandos. Estos argumentos se pueden utilizar dentro del script para realizar diferentes acciones. Aquí te muestro cómo trabajar con argumentos en un script de Bash.

### Crear un Script con Argumentos

1. **Crear el Script**

Abre tu editor de texto y crea un archivo llamado example\_script.sh.

```bash

nano example_script.sh

```

2. **Escribir el Script**

Aquí hay un ejemplo simple de un script que utiliza argumentos:

```bash

#!/bin/bash

# Verifica si se proporcionaron al menos dos argumentos

if [ "$#" -lt 2 ]; then

echo "Usage: $0 <name> <age>"

exit 1

# Asigna los argumentos a variables

NAME=$1

AGE=$2

# Muestra un mensaje usando los argumentos

echo "Hello, $NAME! You are $AGE years old."

```

- $0 es el nombre del script.

- $1, $2, etc., son los argumentos proporcionados al script.

3. **Hacer el Script Ejecutable**

Cambia los permisos del archivo para hacerlo ejecutable:

```bash

chmod +x example_script.sh

```

4. **Ejecutar el Script con Argumentos**

Ejecuta el script pasando dos argumentos:

```bash

./example_script.sh Alice 30

```

Salida esperada:

```

Hello, Alice! You are 30 years old.

```

### Manejo de Argumentos

- **Número de Argumentos**: Usa $# para obtener el número de argumentos pasados al script.

```bash

echo "Number of arguments: $#"

```

- **Argumentos Opcionales**: Puedes proporcionar argumentos opcionales y manejar su ausencia en el script.

```bash

# Verifica si un argumento opcional fue proporcionado

if [ -z "$3" ]; then

echo "No optional argument provided."

else

echo "Optional argument: $3"

```

- **Argumentos con Nombres**: Puedes usar getopts para manejar argumentos con nombres.

```bash

#!/bin/bash

while getopts "n:a:" opt; do

case ${opt} in

n )

NAME=$OPTARG

;;

a )

AGE=$OPTARG

;;

\? )

echo "Invalid option: -$OPTARG" >&2

;;

: )

echo "Invalid option: -$OPTARG requires an argument" >&2

;;

esac

done

echo "Name: $NAME"

echo "Age: $AGE"

```

Ejecuta el script usando opciones con nombres:

```bash

./example_script.sh -n Alice -a 30

```

### Resumen

Los scripts de Bash pueden recibir y manejar argumentos de diversas maneras. Puedes usarlos para pasar datos al script y adaptar su comportamiento según estos datos. Los ejemplos anteriores te proporcionan una base para comenzar a trabajar con argumentos en tus propios scripts.

Sara María Mejia Sánchez

student•

Hola

Les comparto el script 4_argumentos.sh realizado en clase.

Para ejecutar script con agumentos, pasamos el nombre el script y separados por espacio entre comillas pasamos cada uno de los argumentos.

./4_argumentos.sh "Curso de Programación en Bash Shell" "Noches de Platzi"

# !/bin/bash
# Programa para ejemplificar el paso de argumentos

nombreCurso=$1
horarioCurso=$2

echo "El nombre del curso es: $nombreCurso dictado en el horario: $horarioCurso"
echo "El numero de parámetros enviados es: $#"
echo "Los parámetros enviados son: $*"

Saludos

Sandra Guayambuco

student•

Este curso esta muy bueno, entendible todo y claro el camino hacia donde vamos. ⭐⭐⭐⭐⭐

Juan Manuel Hincapié

student•

Ejemplo

Creamos un nuevo script que solicite dos argumentos de la siguiente manera:

# !/bin/bash
# Programa para ejemplificart el paso de argumentos

nombreCurso=$1
horarioCurso=$2

echo "El nombre del curso es: $nombreCurso dictado en el horario de $horarioCurso"
echo "El numero de parámetros enviados es: $#"
echo "Los parámetros enviados son: $*"

Para ejecutar este script se deben enviar los argumentos, así:

bash 4_argumentos.sh "Bash Shell" "Nocturno" #Se recomienda que las cadenas deben ir entre ""

#!/bin/bash 
#
#Ejecución: $ ./parametros.sh argumento1 argumento2 argumento3
#Cuantos argumentos se deseen
#By Dex

 
# Muestra el nombre del script 
printf "\nPARÁMETRO ESPECIAL \$0\n"
echo "El nombre del script es: $0" 

# Muestra el número de parametros
printf "\nPARÁMETRO ESPECIAL \$#\n" 
echo "Hay $# parámetros" 

# Lista de parámetros (en un solo argumento) 
printf "\nPARÁMETRO ESPECIAL \$*\n"
echo "Parámetros (un solo argumento) : $*" 


# Lista de parámetros (un parámetro por argumento) 
printf "\nPARÁMETRO ESPECIAL \$@\n"
echo "Parámetros (un parámetro por argumento) :" 
for param in $@
do 
echo "$param" 
done 

# Muestra el PID del script 
printf "\nPARÁMETRO ESPECIAL \$$\n"
echo "El PID del script ejecutado es: $$" 

# Creamos un proceso en segundo plano 
printf "\nPARÁMETRO ESPECIAL \$!\n"
echo "Abriendo Firefox en segundo plano . . ."
firefox & 

# Muestra el PID del proceso ejecutado en segundo plano 
echo "El PID de Firefox ejecutandose en segundo plano es: $!" 

# Muestra el código de retorno del último comando, en este caso "echo" 
printf "\nPARÁMETRO ESPECIAL \$?\n"
echo "El código de retorno del comando es: $?" 

# Generamos un error para ejemplificar el cas
echo "Generando un error . . ." 
lss -l

# Muestra el código de retorno del último comando 
echo "El código de retorno del comando erróneo es: $?" 

#!/bin/bash 

#Ejecución: $ ./parametros.sh argumento1 argumento2 argumento3
#Cuantos argumentos se deseen
#By Dex

 
# Muestra el nombre del script 
printf "\nPARÁMETRO ESPECIAL \$0\n"
echo "El nombre del script es: $0" 

# Muestra el número de parametros
printf "\nPARÁMETRO ESPECIAL \$#\n" 
echo "Hay $# parámetros" 

# Lista de parámetros (en un solo argumento) 
printf "\nPARÁMETRO ESPECIAL \$*\n"
echo "Parámetros (un solo argumento) : $*" 

# Lista de parámetros (un parámetro por argumento) 
printf "\nPARÁMETRO ESPECIAL \$@\n"
echo "Parámetros (un parámetro por argumento) :" 
for param in $@; do 
  echo "$param" 
done 

# Muestra el PID del script 
printf "\nPARÁMETRO ESPECIAL \$$\n"
echo "El PID del script ejecutado es: $$" 

# Creamos un proceso en segundo plano 
printf "\nPARÁMETRO ESPECIAL \$!\n"
echo "Ejecutando el comando 'sleep' ejecución en segundo plano..."
sleep 10 & 

# Muestra el PID del proceso ejecutado en segundo plano 
echo "El PID del comando 'sleep' en segundo plano es: $!" 

# Muestra el código de retorno del último comando, en este caso "echo " 
printf "\nPARÁMETRO ESPECIAL \$?\n"
echo "El código de retorno del comando es: $?" 

# Generamos un error para ejemplificar el cas
echo "Generando un error..." 
lss -l

# Muestra el código de retorno del último comando 
echo "El código de retorno del comando erróneo es: $?" 

#!/usr/bin/env bash
#lec_4_file
#Executing scripts with arguments

# $0 //tp get the name of the script
# $1 $(10) //tp get the arguments
# $# //to count arguments
# $* to print all the arguments

courseName=$1 #//first argument to courseName
courseTimetable=$2

echo "parameters:"
echo "courseName:$courseName"
echo "courseShip:$courseTimetable"

echo "parameters number:$#"
echo "list parameters:$*"

#to execute use:
# bash lec_4_file.sh "name course" "18:00 to 20:00" "OTHER_I" "OTHER_II"

# !/bin/bash
# Programa para ejemplificar el paso de argumentos

nombreCurso=$1
horarioCurso=$2
echo "El nombre del curso es: $nombreCurso dictado en el horario de $horarioCurso"
echo "El numero de parametros enviados es: $#"
echo "Los parametros enviados son: $*"

 # ! /bin/bash
consentida_uno=$1
consentida_dos=$2

echo "los perritos consentidos son $consentida_uno y $consendida_dos "
echo "el numero de parametros enviados es $# "```
pero el output es:
Business Intelligence$ ./3_pasarVariables.sh "papita" "pepe"
los perritos consentidos son papita y
el numero de parametros enviados es 2
¿que estoy haciendo mal?

# !/bin/bash
# Programa para ejemplificar el paso de argumentos

nombreCurso=$1
horarioCurso=$2

echo "El nombre del curso es: $nombreCurso dictado en el horario: $horarioCurso"
echo "El numero de parámetros enviados es: $#"
echo "Los parámetros enviados son: $*"

# !/bin/bash
# Programa para ejemplificart el paso de argumentos

nombreCurso=$1
horarioCurso=$2

echo "El nombre del curso es: $nombreCurso dictado en el horario de $horarioCurso"
echo "El numero de parámetros enviados es: $#"
echo "Los parámetros enviados son: $*"

Scripts Bash con argumentos: $1, $2, ${10}, $# y $*

Bienvenida e Introducción

Programación Bash para automatizar Postgres

Arquitectura de Linux para programar Bash

Bash scripting

Crear nuestro primer Script

Ejecutar nuestro script con un nombre único

Programación Shell Básica

Declaración de Variables y Alcance en Bash Shell

Tipos de Operadores