Declaración de variables en Linux

Introducción

En este laboratorio, aprenderás sobre las variables en la programación de scripts de shell de Linux, que son esenciales para almacenar y manipular datos en tus scripts. Las variables te permiten almacenar información temporalmente durante la ejecución del script y reutilizar esa información en todo tu código.

Comprender cómo declarar y usar variables es una habilidad fundamental para escribir scripts de shell de Linux. Este conocimiento te ayudará a automatizar tareas, gestionar configuraciones y crear scripts más dinámicos para diversas aplicaciones.

Al final de este laboratorio, entenderás cómo crear variables simples, variables enteras y matrices (arrays) en scripts de bash, que son los bloques de construcción para técnicas de programación de shell más avanzadas.

Skills Graph

Declaración básica de variables

En este paso, aprenderás cómo declarar y usar una variable básica en un script de bash. Las variables en los scripts de shell de Linux te permiten almacenar datos temporalmente y hacer referencia a ellos más adelante en tu script.

Primero, creemos un directorio para nuestro proyecto y naveguemos hacia él:

mkdir -p ~/project
cd ~/project

Ahora, crea un script llamado variables.sh utilizando el editor de texto nano:

nano ~/project/variables.sh

Dentro del editor, escribe el siguiente contenido:

#!/bin/bash

## Declarando una variable básica
BALLOON_COLOR="red"

## Mostrando el valor de la variable
echo "The balloon color is: $BALLOON_COLOR"

En este script, hemos declarado una variable llamada BALLOON_COLOR y le hemos asignado el valor "red". El comando echo muestra luego el valor de esta variable.

Para guardar el archivo en nano, presiona Ctrl+O, luego presiona Enter para confirmar. Para salir de nano, presiona Ctrl+X.

Ahora, haz el script ejecutable:

chmod +x ~/project/variables.sh

Este comando otorga al archivo permiso de ejecución, lo que te permite ejecutarlo como un programa.

Finalmente, ejecuta tu script:

./variables.sh

Deberías ver la siguiente salida:

The balloon color is: red

Esto muestra que tu variable se ha declarado correctamente y que su valor se puede acceder utilizando el símbolo $ antes del nombre de la variable.

Declaración de variables enteras

En este paso, aprenderás cómo declarar y usar variables enteras en scripts de bash. La bandera -i le indica a bash que la variable debe tratarse como un entero, lo cual puede ser útil para operaciones numéricas.

Abre nuevamente el script variables.sh para editarlo:

nano ~/project/variables.sh

Modifica el script para incluir una variable entera:

#!/bin/bash

## Declarando una variable de cadena básica
BALLOON_COLOR="red"

## Declarando una variable entera
declare -i BALLOON_SIZE=10

## Mostrando ambas variables
echo "The balloon color is: $BALLOON_COLOR"
echo "The balloon size is: $BALLOON_SIZE inches"

## Realizando aritmética con la variable entera
declare -i DOUBLE_SIZE=BALLOON_SIZE*2
echo "Double the size would be: $DOUBLE_SIZE inches"

En este script actualizado:

1. Hemos mantenido nuestra variable de cadena original BALLOON_COLOR
2. Hemos agregado una nueva variable entera BALLOON_SIZE utilizando la sintaxis declare -i
3. Hemos demostrado cómo realizar operaciones aritméticas con variables enteras

Guarda el archivo con Ctrl+O y Enter, luego sal de nano con Ctrl+X.

Ahora ejecuta el script nuevamente:

./variables.sh

Deberías ver la siguiente salida:

The balloon color is: red
The balloon size is: 10 inches
Double the size would be: 20 inches

La declaración -i permite que bash reconozca que la variable debe tratarse como un entero, lo que hace posible realizar operaciones aritméticas. Esto es particularmente útil para contadores, cálculos y procesamiento numérico en tus scripts.

Trabajando con variables de arrays

En este paso, aprenderás cómo declarar y usar variables de arrays. Los arrays te permiten almacenar múltiples valores bajo un solo nombre de variable, lo cual es útil cuando se trabaja con colecciones de datos relacionados.

Editemos nuevamente nuestro script:

nano ~/project/variables.sh

Actualiza el script para incluir una variable de array:

#!/bin/bash

## Declaring a basic string variable
BALLOON_COLOR="red"

## Declaring an integer variable
declare -i BALLOON_SIZE=10

## Declaring an array variable
declare -a BALLOON_COLORS=("red" "green" "blue" "purple" "yellow")

## Displaying individual variables
echo "The balloon color is: $BALLOON_COLOR"
echo "The balloon size is: $BALLOON_SIZE inches"

## Displaying all array elements
echo "Available balloon colors are: ${BALLOON_COLORS[*]}"

## Displaying specific array elements
echo "The first color is: ${BALLOON_COLORS[0]}"
echo "The third color is: ${BALLOON_COLORS[2]}"

## Count of array elements
echo "Number of available colors: ${#BALLOON_COLORS[@]}"

En este script actualizado:

1. Hemos mantenido nuestras variables existentes
2. Hemos agregado una variable de array BALLOON_COLORS utilizando la sintaxis declare -a
3. Hemos mostrado diferentes formas de acceder a los elementos del array:
   • ${BALLOON_COLORS[*]} muestra todos los elementos
   • ${BALLOON_COLORS[0]} accede al primer elemento (los arrays en bash tienen índice cero)
   • ${#BALLOON_COLORS[@]} da el número de elementos en el array

Guarda el archivo con Ctrl+O y Enter, luego sal de nano con Ctrl+X.

Ahora ejecuta el script nuevamente:

./variables.sh

Deberías ver la siguiente salida:

The balloon color is: red
The balloon size is: 10 inches
Available balloon colors are: red green blue purple yellow
The first color is: red
The third color is: blue
Number of available colors: 5

Los arrays son poderosos cuando necesitas manejar colecciones de datos relacionados. Te permiten organizar múltiples valores y acceder a ellos individualmente o como grupo. Esto es especialmente útil para manejar listas de elementos, como nombres de archivos, información de usuarios o opciones de configuración.

Manipulación y expansión de variables

En este paso, aprenderás cómo manipular y expandir variables de diferentes maneras. Estas técnicas te permiten modificar los valores de las variables sin crear nuevas variables, lo cual es útil para el procesamiento de texto y la transformación de datos.

Editemos nuevamente nuestro script:

nano ~/project/variables.sh

Actualiza el script para demostrar la manipulación de variables:

#!/bin/bash

## Declaring basic variables
NAME="linux"
MESSAGE="Hello, world!"
FILE_PATH="/home/user/documents/report.txt"

echo "Original values:"
echo "NAME = $NAME"
echo "MESSAGE = $MESSAGE"
echo "FILE_PATH = $FILE_PATH"

echo -e "\nVariable manipulation examples:"

## Convert to uppercase
echo "NAME in uppercase: ${NAME^^}"

## Convert to lowercase
UPPER_NAME="LINUX"
echo "UPPER_NAME in lowercase: ${UPPER_NAME,,}"

## Get string length
echo "Length of MESSAGE: ${#MESSAGE}"

## Extract substring (starting at position 7, 5 characters)
echo "Substring of MESSAGE: ${MESSAGE:7:5}"

## Replace part of string
echo "Replace 'world' with 'Linux': ${MESSAGE/world/Linux}"

## Extract filename from path
echo "Filename from path: ${FILE_PATH##*/}"

## Extract directory from path
echo "Directory from path: ${FILE_PATH%/*}"

## Default value if variable is unset
UNSET_VAR=""
echo "Default value example: ${UNSET_VAR:-default value}"

Este script demuestra varios métodos para manipular variables:

1. ${NAME^^} - Convertir a mayúsculas
2. ${UPPER_NAME,,} - Convertir a minúsculas
3. ${#MESSAGE} - Obtener la longitud de la cadena
4. ${MESSAGE:7:5} - Extraer una subcadena (posición y longitud)
5. ${MESSAGE/world/Linux} - Reemplazar parte de la cadena
6. ${FILE_PATH##*/} - Eliminar la coincidencia más larga desde el principio (extraer el nombre del archivo)
7. ${FILE_PATH%/*} - Eliminar la coincidencia más corta desde el final (extraer el directorio)
8. ${UNSET_VAR:-default value} - Usar un valor predeterminado si la variable no está definida

Guarda el archivo con Ctrl+O y Enter, luego sal de nano con Ctrl+X.

Ahora ejecuta el script:

./variables.sh

Deberías ver una salida similar a la siguiente:

Original values:
NAME = linux
MESSAGE = Hello, world!
FILE_PATH = /home/user/documents/report.txt

Variable manipulation examples:
NAME in uppercase: LINUX
UPPER_NAME in lowercase: linux
Length of MESSAGE: 13
Substring of MESSAGE: world
Replace 'world' with 'Linux': Hello, Linux!
Filename from path: report.txt
Directory from path: /home/user/documents
Default value example: default value

Estas técnicas de manipulación de variables son extremadamente útiles para procesar datos de texto, extraer información de cadenas y manejar valores predeterminados en tus scripts.

Variables de entorno y ámbito de las variables

En este último paso, aprenderás sobre las variables de entorno, el ámbito de las variables y cómo exportar variables para que estén disponibles para otros procesos.

Crea un nuevo script llamado environment.sh:

nano ~/project/environment.sh

Agrega el siguiente contenido:

#!/bin/bash

## Displaying some common environment variables
echo "USER: $USER"
echo "HOME: $HOME"
echo "PATH: $PATH"
echo "PWD: $PWD"
echo "SHELL: $SHELL"

## Creating a local variable
LOCAL_VAR="This is a local variable"
echo "LOCAL_VAR: $LOCAL_VAR"

## Exporting a variable to make it available to child processes
export EXPORTED_VAR="This variable is exported"
echo "EXPORTED_VAR: $EXPORTED_VAR"

## Demonstrate how variables work in subshells
echo -e "\nVariable behavior in subshell:"
(
  echo "Inside subshell:"
  echo "  LOCAL_VAR: $LOCAL_VAR"
  echo "  EXPORTED_VAR: $EXPORTED_VAR"
  echo "  Creating subshell-only variable"
  SUBSHELL_VAR="This variable only exists in the subshell"
  echo "  SUBSHELL_VAR: $SUBSHELL_VAR"
)

echo -e "\nAfter subshell:"
echo "LOCAL_VAR: $LOCAL_VAR"
echo "EXPORTED_VAR: $EXPORTED_VAR"
echo "SUBSHELL_VAR: $SUBSHELL_VAR" ## This will be empty

## Creating a script to test export behavior
echo -e "\nCreating child script to test variable export..."
cat > ~/project/child_script.sh << 'EOF'
#!/bin/bash
echo "In child script:"
echo "EXPORTED_VAR: $EXPORTED_VAR"
echo "LOCAL_VAR: $LOCAL_VAR"
EOF

chmod +x ~/project/child_script.sh

## Run the child script
echo -e "\nRunning child script:"
./child_script.sh

Este script demuestra:

1. Variables de entorno comunes (USER, HOME, PATH, etc.)
2. La diferencia entre variables locales y exportadas
3. El comportamiento de las variables en subshells (los paréntesis crean un subshell)
4. Cómo las variables exportadas son heredadas por los procesos hijos

Guarda el archivo con Ctrl+O y Enter, luego sal de nano con Ctrl+X.

Haz el script ejecutable:

chmod +x ~/project/environment.sh

Ahora ejecuta el script:

./environment.sh

La salida te mostrará cómo se comportan las variables en diferentes contextos:

• Las variables de entorno están preestablecidas por el sistema
• Las variables locales solo existen en el script actual
• Las variables exportadas se pasan a los procesos hijos
• Las variables creadas en subshells no están disponibles en el shell padre

Comprender el ámbito de las variables es crucial cuando se escriben scripts complejos que crean procesos hijos o importan otros scripts. Ayuda a gestionar el flujo de datos entre diferentes partes de tu sistema.

Resumen

En este laboratorio, has aprendido los fundamentos de la declaración y manipulación de variables en scripting de shell de Linux. Has explorado:

• Declaración y uso básicos de variables
• Variables enteras y operaciones aritméticas
• Variables de arrays (matrices) para almacenar colecciones de datos
• Técnicas de manipulación de variables para el procesamiento de texto
• Variables de entorno y ámbito de las variables

Estas habilidades forman la base del scripting de shell y son esenciales para automatizar tareas en entornos Linux. Las variables te permiten crear scripts más dinámicos y flexibles al almacenar y procesar datos durante la ejecución.

Ahora puedes utilizar estas técnicas para:

• Almacenar configuraciones en tus scripts
• Procesar la entrada del usuario y el contenido de archivos
• Manipular datos de texto y rutas de archivos
• Compartir datos entre diferentes scripts y procesos

A medida que continúes tu viaje en el scripting de shell de Linux, descubrirás que dominar el uso de variables abre muchas posibilidades para crear herramientas de automatización potentes y eficientes.