Trabajo con Variables de Shell

Introducción

En este laboratorio, aprenderás a trabajar con variables de shell en Linux. Las variables de shell son fundamentales para almacenar y manipular datos en los scripts. Pueden contener diversos tipos de valores, como números, caracteres o cadenas de texto. Este laboratorio te guiará a través de la creación, referenciación y uso de variables de shell, proporcionando una base sólida para la programación en shell.

Crear Variables de Shell

Las variables de shell se crean asignándoles un valor mediante el signo =. Comencemos creando un script de shell sencillo que defina algunas variables.

1. Abre una terminal en tu WebIDE (VS Code).

2. Crea un nuevo archivo llamado variables.sh en el directorio /home/labex/project:

   touch /home/labex/project/variables.sh
   

3. Abre el archivo variables.sh en el WebIDE y añade el siguiente contenido:

   #!/bin/bash
   
   PRICE_PER_APPLE=5
   MyFirstLetters=ABC
   greeting='Hello        world!'
   
   echo "Price per apple: $PRICE_PER_APPLE"
   echo "My first letters: $MyFirstLetters"
   echo "Greeting: $greeting"
   

   En este script, hemos creado tres variables:

   • PRICE_PER_APPLE: Una variable de tipo entero.
   • MyFirstLetters: Una variable de cadena de texto.
   • greeting: Una variable de cadena con múltiples espacios.

4. Guarda el archivo.

5. Dale permisos de ejecución al script:

   chmod +x /home/labex/project/variables.sh
   

6. Ejecuta el script:

   ./variables.sh
   

   Deberías ver la siguiente salida:

   Price per apple: 5
   My first letters: ABC
   Greeting: Hello        world!
   

   Observa que los espacios adicionales en la variable greeting se conservan en la salida al usar comillas simples para definir la variable y no usar comillas en la sentencia echo.

Referenciar Variables de Shell

Al referenciar variables de shell, existen algunos escenarios donde es necesario utilizar una sintaxis especial. Exploremos estos casos.

1. Abre el archivo variables.sh en el WebIDE.

2. Reemplaza el contenido del archivo con lo siguiente:

   #!/bin/bash
   
   PRICE_PER_APPLE=5
   MyFirstLetters=ABC
   greeting='Hello        world!'
   
   ## Escaping special characters
   echo "The price of an Apple today is: \$HK $PRICE_PER_APPLE"
   
   ## Avoiding ambiguity
   echo "The first 10 letters in the alphabet are: ${MyFirstLetters}DEFGHIJ"
   
   ## Preserving whitespace
   echo $greeting
   echo "$greeting"
   

3. Guarda el archivo.

4. Ejecuta el script:

   ./variables.sh
   

   Deberías ver la siguiente salida:

   The price of an Apple today is: $HK 5
   The first 10 letters in the alphabet are: ABCDEFGHIJ
   Hello world!
   Hello        world!
   

   Nota las diferencias:

   • El signo $ se escapa en la primera línea para que se imprima literalmente.
   • Se utilizan llaves {} para definir claramente el nombre de la variable en la segunda línea y evitar ambigüedades con el texto adyacente.
   • Las últimas dos líneas muestran la diferencia entre usar comillas y no usarlas al referenciar una variable que contiene espacios en blanco.

Sustitución de Comandos

La sustitución de comandos te permite utilizar la salida de un comando como el valor de una variable. Esto se logra encerrando el comando entre $() o comillas invertidas (``).

1. Abre el archivo variables.sh en el WebIDE.

2. Añade el siguiente contenido al final del archivo:

   ## Command substitution
   CURRENT_DATE=$(date +"%Y-%m-%d")
   echo "Today's date is: $CURRENT_DATE"
   
   FILES_IN_DIR=$(ls)
   echo "Files in the current directory:"
   echo "$FILES_IN_DIR"
   
   UPTIME=$(uptime -p)
   echo "System uptime: $UPTIME"
   

3. Guarda el archivo.

4. Ejecuta el script:

   ./variables.sh
   

   Deberías ver una salida similar a esta (los valores reales dependerán de tu sistema):

   Today's date is: 2023-08-16
   Files in the current directory:
   variables.sh
   System uptime: up 2 hours, 15 minutes
   

   En este ejemplo:

   • $(date +"%Y-%m-%d") ejecuta el comando date y captura su salida.
   • $(ls) ejecuta el comando ls y captura su salida.
   • $(uptime -p) ejecuta el comando uptime con la opción -p y captura su salida.

Operaciones Aritméticas

Las variables de shell también pueden utilizarse en operaciones aritméticas. Bash proporciona la sintaxis $((expresión)) para realizar cálculos.

1. Crea un nuevo archivo llamado arithmetic.sh en el directorio /home/labex/project:

   touch /home/labex/project/arithmetic.sh
   

2. Abre el archivo arithmetic.sh en el WebIDE y añade el siguiente contenido:

   #!/bin/bash
   
   X=10
   Y=5
   
   ## Addition
   SUM=$((X + Y))
   echo "Sum of $X and $Y is: $SUM"
   
   ## Subtraction
   DIFF=$((X - Y))
   echo "Difference between $X and $Y is: $DIFF"
   
   ## Multiplication
   PRODUCT=$((X * Y))
   echo "Product of $X and $Y is: $PRODUCT"
   
   ## Division
   QUOTIENT=$((X / Y))
   echo "Quotient of $X divided by $Y is: $QUOTIENT"
   
   ## Modulus (remainder)
   REMAINDER=$((X % Y))
   echo "Remainder of $X divided by $Y is: $REMAINDER"
   
   ## Increment
   X=$((X + 1))
   echo "After incrementing, X is now: $X"
   
   ## Decrement
   Y=$((Y - 1))
   echo "After decrementing, Y is now: $Y"
   

3. Guarda el archivo.

4. Dale permisos de ejecución al script:

   chmod +x /home/labex/project/arithmetic.sh
   

5. Ejecuta el script:

   ./arithmetic.sh
   

   Deberías ver la siguiente salida:

   Sum of 10 and 5 is: 15
   Difference between 10 and 5 is: 5
   Product of 10 and 5 is: 50
   Quotient of 10 divided by 5 is: 2
   Remainder of 10 divided by 5 is: 0
   After incrementing, X is now: 11
   After decrementing, Y is now: 4
   

   Este script demuestra varias operaciones aritméticas utilizando variables de shell.

Uso de Variables de Entorno

Las variables de entorno son un tipo de variable que está disponible para todos los procesos que se ejecutan en la sesión actual de la shell. Exploremos algunas variables de entorno comunes y cómo crear las nuestras.

1. Crea un nuevo archivo llamado environment.sh en el directorio /home/labex/project:

   touch /home/labex/project/environment.sh
   

2. Abre el archivo environment.sh en el WebIDE y añade el siguiente contenido:

   #!/bin/bash
   
   ## Displaying some common environment variables
   echo "Home directory: $HOME"
   echo "Current user: $LOGNAME"
   echo "Shell being used: $SHELL"
   echo "Current PATH: $PATH"
   
   ## Creating a new environment variable
   export MY_VARIABLE="Hello from my variable"
   
   ## Displaying the new variable
   echo "My new variable: $MY_VARIABLE"
   
   ## Creating a child process to demonstrate variable scope
   bash -c 'echo "MY_VARIABLE in child process: $MY_VARIABLE"'
   
   ## Removing the environment variable
   unset MY_VARIABLE
   
   ## Verifying the variable is unset
   echo "MY_VARIABLE after unsetting: $MY_VARIABLE"
   

3. Guarda el archivo.

4. Dale permisos de ejecución al script:

   chmod +x /home/labex/project/environment.sh
   

5. Ejecuta el script:

   ./environment.sh
   

   Deberías ver una salida similar a esta (los valores reales dependerán de tu sistema):

   Home directory: /home/labex
   Current user: labex
   Shell being used: /bin/zsh
   Current PATH: /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin
   My new variable: Hello from my variable
   MY_VARIABLE in child process: Hello from my variable
   MY_VARIABLE after unsetting:
   

   Este script demuestra cómo acceder a variables de entorno existentes, crear nuevas y eliminarlas.

Resumen

En este laboratorio, has aprendido a trabajar con variables de shell en Linux. Has explorado cómo crear y referenciar variables, utilizar la sustitución de comandos para asignar salidas de comandos a variables, realizar operaciones aritméticas y trabajar con variables de entorno. Estas habilidades constituyen una base crucial para el scripting en shell y serán invaluables a medida que continúes trabajando con sistemas Linux.

Los puntos clave de este laboratorio incluyen:

• Creación y referenciación de variables de shell.
• Uso de sintaxis especial para la referenciación de variables en diferentes escenarios.
• Utilización de la sustitución de comandos para capturar salidas de procesos.
• Realización de operaciones aritméticas con variables de shell.
• Gestión de variables de entorno.

A medida que avances en tu camino por Linux y el scripting, recuerda que las variables son herramientas poderosas para almacenar y manipular datos. Practica su uso en tus scripts para que tu código sea más flexible y reutilizable.