Variables especiales en el shell

Introducción

En este laboratorio, aprenderás sobre las variables especiales en la programación de scripts de shell. Estas variables proporcionan información esencial sobre el entorno de ejecución del script, como los argumentos de la línea de comandos, el nombre del script y el ID del proceso. Comprender estas variables te ayudará a escribir scripts de shell más flexibles y potentes.

Skills Graph

Creando tu primer script

Comencemos creando un simple script de shell para demostrar el uso de variables especiales.

1. Abre tu terminal en el WebIDE. Deberías ver un indicador de comando esperando tu entrada.

2. Navega hasta el directorio del proyecto:

cd ~/project

Este comando cambia tu directorio actual a ~/project, que es tu directorio de trabajo predeterminado para este laboratorio.

3. Crea un nuevo archivo llamado special_vars.sh usando el siguiente comando:

touch special_vars.sh

El comando touch crea un archivo vacío si no existe, o actualiza su marca de tiempo si ya existe.

4. Abre el archivo en el editor del WebIDE. Puedes hacer esto haciendo clic en el nombre del archivo en el explorador de archivos en el lado izquierdo de tu pantalla.

5. Agrega el siguiente contenido al archivo:

#!/bin/bash

echo "Script Name: $0"
echo "First Argument: $1"
echo "Second Argument: $2"
echo "All Arguments: $@"
echo "Number of Arguments: $#"
echo "Process ID: $$"

Analicemos lo que hace cada línea:

• #!/bin/bash: Esto se llama shebang. Le dice al sistema que use bash para interpretar este script.
• $0: Esta variable especial contiene el nombre del script.
• $1 y $2: Estas representan el primer y segundo argumento de la línea de comandos respectivamente.
• $@: Esto representa todos los argumentos de la línea de comandos pasados al script.
• $#: Esto da la cantidad de argumentos de la línea de comandos.
• $$: Esto proporciona el ID del proceso de la shell actual.

6. Guarda el archivo después de agregar el contenido.

7. Haz que el script sea ejecutable ejecutando el siguiente comando en tu terminal:

chmod +x special_vars.sh

El comando chmod cambia los permisos de un archivo. La opción +x agrega permiso de ejecución, lo que te permite ejecutar el script.

Ejecutando el script con argumentos

Ahora que hemos creado nuestro script, ejecutémoslo con diferentes argumentos para ver cómo se comportan las variables especiales.

1. Ejecuta el script sin ningún argumento:

./special_vars.sh

El ./ antes del nombre del script le dice a la shell que busque el script en el directorio actual.

Deberías ver una salida similar a esta:

Script Name:./special_vars.sh
First Argument:
Second Argument:
All Arguments:
Number of Arguments: 0
Process ID: 1234

Observa que el primer y segundo argumentos están vacíos, y el número de argumentos es 0 ya que no proporcionamos ninguno.

2. Ahora, ejecuta el script con algunos argumentos:

./special_vars.sh hello world

La salida debería verse así:

Script Name:./special_vars.sh
First Argument: hello
Second Argument: world
All Arguments: hello world
Number of Arguments: 2
Process ID: 1235

Esto es lo que cambió:

• $1 ahora contiene "hello"
• $2 ahora contiene "world"
• $@ muestra todos los argumentos: "hello world"
• $# muestra 2, porque proporcionamos dos argumentos

El ID del proceso ($$) puede ser diferente cada vez que ejecutas el script, ya que es asignado por el sistema operativo.

Entendiendo $? y $!

Otras dos variables especiales importantes son $? y $!. Creemos un nuevo script para demostrar su uso.

1. Crea un nuevo archivo llamado exit_status.sh:

touch ~/project/exit_status.sh

2. Abre el archivo en el editor del WebIDE y agrega el siguiente contenido:

#!/bin/bash

echo "Running a successful command:"
ls /home
echo "Exit status: $?"

echo "Running a command that will fail:"
ls /nonexistent_directory
echo "Exit status: $?"

echo "Running a background process:"
sleep 2 &
echo "Process ID of last background command: $!"

Analicemos este script:

• $? da el estado de salida del último comando ejecutado. 0 típicamente significa éxito, mientras que valores distintos de cero indican diversas condiciones de error.
• $! da el ID del proceso del último comando ejecutado en segundo plano.
• El & al final de un comando lo ejecuta en segundo plano.

3. Guarda el archivo y hazlo ejecutable:

chmod +x ~/project/exit_status.sh

4. Ejecuta el script:

./exit_status.sh

Deberías ver una salida similar a esta:

Running a successful command:
labex
Exit status: 0
Running a command that will fail:
ls: cannot access '/nonexistent_directory': No such file or directory
Exit status: 2
Running a background process:
Process ID of last background command: 1236

Observa:

• El primer comando ls tiene éxito, por lo que $? es 0.
• El segundo comando ls falla (porque el directorio no existe), por lo que $? es 2 (un valor distinto de cero que indica un error).
• El comando sleep se ejecuta en segundo plano, y $! da su ID de proceso.

Usando variables especiales en funciones

Las variables especiales también se pueden utilizar dentro de funciones. Creemos un script para demostrar esto.

1. Crea un nuevo archivo llamado function_vars.sh:

touch ~/project/function_vars.sh

2. Abre el archivo en el editor del WebIDE y agrega el siguiente contenido:

#!/bin/bash

function print_args {
  echo "Function Name: $0"
  echo "First Argument: $1"
  echo "Second Argument: $2"
  echo "All Arguments: $@"
  echo "Number of Arguments: $#"
}

echo "Calling function with two arguments:"
print_args hello world

echo "Calling function with four arguments:"
print_args one two three four

Este script define una función print_args que utiliza variables especiales. Luego llama a esta función dos veces con diferentes cantidades de argumentos.

3. Guarda el archivo y hazlo ejecutable:

chmod +x ~/project/function_vars.sh

4. Ejecuta el script:

./function_vars.sh

Deberías ver una salida similar a esta:

Calling function with two arguments:
Function Name:./function_vars.sh
First Argument: hello
Second Argument: world
All Arguments: hello world
Number of Arguments: 2
Calling function with four arguments:
Function Name:./function_vars.sh
First Argument: one
Second Argument: two
All Arguments: one two three four
Number of Arguments: 4

Observa que:

• $0 todavía se refiere al nombre del script, no al nombre de la función.
• $1, $2, $@ y $# funcionan para los argumentos de la función de la misma manera que para los argumentos del script.
• Los valores de estas variables cambian cada vez que se llama a la función con diferentes argumentos.

Entendiendo la diferencia entre $@ y $*

Las variables especiales $@ y $* se utilizan para representar todos los argumentos de la línea de comandos, pero se comportan de manera diferente cuando se encierran entre comillas dobles. Creemos un script para demostrar esta diferencia.

1. Crea un nuevo archivo llamado at_vs_star.sh:

touch ~/project/at_vs_star.sh

2. Abre el archivo en el editor del WebIDE y agrega el siguiente contenido:

#!/bin/bash

echo "Using \$@:"
for arg in "$@"; do
  echo "Argument: $arg"
done

echo "Using \$*:"
for arg in "$*"; do
  echo "Argument: $arg"
done

Este script demuestra la diferencia entre $@ y $* cuando se utilizan en un bucle.

3. Guarda el archivo y hazlo ejecutable:

chmod +x ~/project/at_vs_star.sh

4. Ejecuta el script con múltiples argumentos, incluyendo algunos con espacios:

./at_vs_star.sh "arg with spaces" another_arg "third arg"

Deberías ver una salida similar a esta:

Using $@:
Argument: arg with spaces
Argument: another_arg
Argument: third arg
Using $*:
Argument: arg with spaces another_arg third arg

Esto es lo que está sucediendo:

• Con "$@", cada argumento se trata como una entidad separada. Los argumentos con espacios se conservan como unidades individuales.
• Con "$*", todos los argumentos se combinan en una sola cadena, separados por el primer carácter de la variable IFS (Internal Field Separator, separador de campos interno), que por lo general es un espacio.

Esta diferencia es crucial cuando necesitas procesar argumentos que pueden contener espacios u otros caracteres especiales.

Resumen

En este laboratorio, has aprendido sobre las variables especiales en la programación de scripts de shell y cómo utilizarlas de manera efectiva. Has creado scripts que demuestran el uso de diversas variables especiales como $0, $1, $@, $#, $$, $? y $!. También has explorado cómo se comportan estas variables en diferentes contextos, incluyendo dentro de funciones y al manejar argumentos de la línea de comandos.

Puntos clave:

1. $0, $1, $2, etc. representan el nombre del script y los argumentos de la línea de comandos.
2. $@ y $# te permiten trabajar con todos los argumentos y contarlos.
3. $$ te da el ID del proceso actual, útil para crear archivos temporales únicos.
4. $? te ayuda a comprobar si el comando anterior tuvo éxito.
5. $! te da el PID del último proceso en segundo plano, útil para el control de trabajos.
6. $@ y $* se comportan de manera diferente cuando se encierran entre comillas, lo cual es importante al manejar argumentos con espacios.

Comprender estas variables especiales es crucial para escribir scripts de shell más avanzados y flexibles. Te permiten crear scripts que pueden adaptarse a diferentes entradas y proporcionar información valiosa sobre el entorno de ejecución del script.

A medida que sigas practicando y experimentando con la programación de scripts de shell, encontrarás muchas más formas de aprovechar estas variables especiales en tu trabajo. Recuerda consultar el manual de bash (man bash) para obtener información más detallada sobre estas y otras variables especiales.