Solución de Problemas de Variables No Definidas en Scripts de Bash | Guía Completa

Introducción

Las variables no definidas en los scripts de Bash pueden llevar a comportamientos y errores inesperados. En este tutorial, exploraremos los fundamentos de las variables de shell, aprenderemos a identificar cuándo las variables no están definidas (unbound) y a implementar estrategias efectivas para manejarlas. Al final de este laboratorio, podrás escribir scripts de Bash más confiables que gestionen los problemas de variables de manera adecuada.

Creando tu Primer Script con Variables de Shell

Las variables de shell son ubicaciones de almacenamiento con nombre que contienen valores en tus scripts de Bash. En este paso, crearemos un script simple para entender cómo funcionan las variables y ver cómo se utilizan.

Entendiendo las Variables de Shell

Las variables en Bash te permiten almacenar datos que pueden ser referenciados y manipulados a lo largo de tu script. Son esenciales para escribir scripts flexibles y reutilizables.

Comencemos creando un nuevo archivo de script en nuestro directorio del proyecto:

Abre el WebIDE y crea un nuevo archivo llamado variables.sh en el directorio /home/labex/project
Agrega el siguiente contenido al archivo:

#!/bin/bash

## Declarando variables
name="LabEx User"
age=25
current_date=$(date)

## Accediendo a variables
echo "Hello, my name is $name"
echo "I am $age years old"
echo "Today is: $current_date"

## Variables with spaces need quotes
greeting="Welcome to Bash scripting"
echo "$greeting"

Guarda el archivo
Haz que el script sea ejecutable ejecutando este comando en la terminal:

chmod +x variables.sh

Ejecuta tu script:

./variables.sh

Deberías ver una salida similar a esta:

Hello, my name is LabEx User
I am 25 years old
Today is: Mon Jan 1 12:34:56 UTC 2023
Welcome to Bash scripting

Reglas de Nombres de Variables

Al nombrar variables en Bash, ten en cuenta estas reglas:

Los nombres de las variables pueden contener letras, números y guiones bajos (underscores)
Los nombres de las variables no pueden comenzar con un número
No se permiten espacios alrededor del signo igual al asignar valores
Los nombres de las variables distinguen entre mayúsculas y minúsculas (NAME y name son variables diferentes)

Agreguemos algunos ejemplos más a nuestro script. Abre variables.sh de nuevo y agrega lo siguiente al final:

## Examples of valid variable names
user_1="John"
HOME_DIR="/home/user"
count=42

## Printing the variables
echo "User: $user_1"
echo "Home directory: $HOME_DIR"
echo "Count: $count"

Guarda el archivo y ejecútalo de nuevo:

./variables.sh

La salida adicional debería verse así:

User: John
Home directory: /home/user
Count: 42

¡Ahora has creado tu primer script de Bash que usa variables correctamente!

Encontrando Variables No Definidas

Ahora que entendemos los conceptos básicos de las variables, exploremos qué sucede cuando intentamos usar una variable a la que no se le ha asignado un valor: una variable no definida (unbound).

¿Qué son las Variables No Definidas?

Una variable no definida, también llamada variable sin establecer (unset), es aquella a la que no se le ha asignado un valor en tu script. Cuando intentas usar una variable no definida, Bash típicamente la trata como una cadena vacía, lo que puede causar errores sutiles en tus scripts.

Creemos un nuevo script para ver esto en acción:

Crea un nuevo archivo llamado unbound.sh en tu directorio del proyecto con el siguiente contenido:

#!/bin/bash

## A variable that is properly set
username="labex"

## Try to use a variable that hasn't been set
echo "Hello, $username! Your home directory is $home_dir"

## Try to do math with an unbound variable
total=$((count + 5))
echo "Total: $total"

Haz que el script sea ejecutable:

chmod +x unbound.sh

Ejecuta el script:

./unbound.sh

Deberías ver una salida similar a esta:

Hello, labex! Your home directory is

Total: 5

Observa que $home_dir aparece como un espacio en blanco, y $count se trata como 0 en el cálculo. Este comportamiento silencioso puede llevar a errores que son difíciles de encontrar.

Detectando Variables No Definidas

Modifiquemos nuestro script para ayudar a detectar estas variables no definidas. Una forma de hacerlo es usar comprobaciones condicionales antes de usar las variables:

Abre unbound.sh y reemplaza su contenido con:

#!/bin/bash

## A variable that is properly set
username="labex"

## Check if home_dir is set before using it
if [ -z "$home_dir" ]; then
  echo "Warning: home_dir is not set!"
  home_dir="/home/default"
  echo "Using default: $home_dir"
else
  echo "Home directory is: $home_dir"
fi

## Check if count is set before doing math
if [ -z "$count" ]; then
  echo "Warning: count is not set!"
  count=10
  echo "Using default count: $count"
fi

total=$((count + 5))
echo "Total: $total"

Guarda el archivo y ejecútalo de nuevo:

./unbound.sh

La salida ahora debería ser:

Warning: home_dir is not set!
Using default: /home/default
Warning: count is not set!
Using default count: 10
Total: 15

Este enfoque te ayuda a detectar variables no definidas y a manejarlas explícitamente en lugar de permitir que causen errores silenciosos.

Probando con la Opción `set -u`

Otra forma de detectar variables no definidas es usar la opción set -u, que hace que Bash salga inmediatamente cuando encuentra una variable no definida:

Crea un nuevo archivo llamado strict.sh con el siguiente contenido:

#!/bin/bash
set -u ## Exit when unbound variable is used

echo "My username is $username"
echo "My favorite color is $favorite_color"
echo "This line won't be reached if favorite_color isn't set"

Hazlo ejecutable:

chmod +x strict.sh

Ejecuta el script:

./strict.sh

Deberías ver un mensaje de error similar a:

./strict.sh: line 4: favorite_color: unbound variable

El script sale inmediatamente en la línea 4 cuando intenta usar la variable no definida $favorite_color. Esto ayuda a detectar variables no definidas temprano, previniendo posibles problemas más adelante en el script.

Manejo de Variables No Definidas con Expansión de Parámetros

Una de las características más poderosas de Bash para manejar variables no definidas es la expansión de parámetros (parameter expansion). Te permite proporcionar valores predeterminados y realizar diversas operaciones en variables.

Usando Valores Predeterminados con Expansión de Parámetros

La expansión de parámetros proporciona varias formas de manejar variables no definidas de manera elegante. Creemos un nuevo script para demostrar estas técnicas:

Crea un nuevo archivo llamado parameter_expansion.sh con el siguiente contenido:

#!/bin/bash

## Default value with ${parameter:-default}
## If parameter is unset or null, 'default' is used
echo "1. Username: ${username:-anonymous}"

## Define username and try again
username="labex"
echo "2. Username: ${username:-anonymous}"

## Default value with ${parameter-default}
## Only if parameter is unset, 'default' is used
unset username
empty_var=""
echo "3. Username (unset): ${username-anonymous}"
echo "4. Empty variable: ${empty_var-not empty}"

## Assign default with ${parameter:=default}
## If parameter is unset or null, set it to 'default'
echo "5. Language: ${language:=bash}"
echo "6. Language is now set to: $language"

## Display error with ${parameter:?message}
## If parameter is unset or null, show error message and exit
echo "7. About to check required parameter..."
## Uncomment the line below to see the error
## echo "Config file: ${config_file:?not specified}"

echo "8. Script continues..."

Haz que el script sea ejecutable:

chmod +x parameter_expansion.sh

Ejecuta el script:

./parameter_expansion.sh

Deberías ver una salida como esta:

1. Username: anonymous
2. Username: labex
3. Username (unset): anonymous
4. Empty variable:
5. Language: bash
6. Language is now set to: bash
7. About to check required parameter...
8. Script continues...

Patrones Comunes de Expansión de Parámetros

Aquí hay un resumen de los patrones de expansión de parámetros que acabamos de usar:

Sintaxis	Descripción
`${var:-default}`	Usa el valor predeterminado si var no está definido o es nulo
`${var-default}`	Usa el valor predeterminado solo si var no está definido
`${var:=default}`	Establece var al valor predeterminado si no está definido o es nulo
`${var:?message}`	Muestra un error si var no está definido o es nulo

Creando un Ejemplo Práctico

Creemos un script más práctico que use la expansión de parámetros para manejar la configuración:

Crea un nuevo archivo llamado config_script.sh con el siguiente contenido:

#!/bin/bash

## Script that processes files with configurable settings

## Use parameter expansion to set defaults for all configuration options
BACKUP_DIR=${BACKUP_DIR:-"/tmp/backups"}
MAX_FILES=${MAX_FILES:-5}
FILE_TYPE=${FILE_TYPE:-"txt"}
VERBOSE=${VERBOSE:-"no"}

echo "Configuration settings:"
echo "----------------------"
echo "Backup directory: $BACKUP_DIR"
echo "Maximum files: $MAX_FILES"
echo "File type: $FILE_TYPE"
echo "Verbose mode: $VERBOSE"

## Create backup directory if it doesn't exist
if [ ! -d "$BACKUP_DIR" ]; then
  echo "Creating backup directory: $BACKUP_DIR"
  mkdir -p "$BACKUP_DIR"
fi

## Search for files of specified type (in current directory for demo)
echo "Searching for .$FILE_TYPE files..."
file_count=$(find . -maxdepth 1 -name "*.$FILE_TYPE" | wc -l)

echo "Found $file_count .$FILE_TYPE files"

## Enable verbose output if requested
if [ "$VERBOSE" = "yes" ]; then
  echo "Files found:"
  find . -maxdepth 1 -name "*.$FILE_TYPE" -type f
fi

echo "Script completed successfully!"

Haz que el script sea ejecutable:

chmod +x config_script.sh

Ejecuta el script con los valores predeterminados:

./config_script.sh

Ahora ejecútalo de nuevo con algunas configuraciones personalizadas:

FILE_TYPE="sh" VERBOSE="yes" ./config_script.sh

La salida debería mostrar tus scripts de bash (archivos .sh) en el directorio actual.

Este script demuestra cómo usar la expansión de parámetros para establecer valores predeterminados para las variables de configuración, haciendo que tu script sea flexible y fácil de usar.

Uso del Modo Estricto para Scripts Robustos

Para crear scripts de Bash más confiables y resistentes a errores, muchos desarrolladores usan lo que a menudo se llama "modo estricto" (strict mode). Esto incluye un conjunto de opciones de Bash que ayudan a detectar errores comunes, incluyendo variables no definidas.

¿Qué es el Modo Estricto?

El modo estricto típicamente implica habilitar estas opciones al principio de tu script:

set -e: Salir inmediatamente si un comando sale con un estado distinto de cero
set -u: Salir si se hace referencia a una variable no definida
set -o pipefail: Hace que una tubería (pipeline) falle si algún comando en ella falla

Veamos cómo implementar esto en un script:

Crea un nuevo archivo llamado strict_mode.sh con el siguiente contenido:

#!/bin/bash
## Strict mode
set -euo pipefail

echo "Starting strict mode script..."

## Define some variables
username="labex"
project_dir="/home/labex/project"

## This function requires two parameters
process_data() {
  local input="$1"
  local output="${2:-output.txt}"

  echo "Processing $input and saving to $output"
  ## For demo purposes, just echo to the output file
  echo "Processed data from $input" > "$output"
}

## Call the function with required arguments
process_data "input.txt"

## Try to access a non-existent file
## Uncomment the next line to see how strict mode handles errors
## cat non_existent_file.txt

echo "Script completed successfully"

Haz que el script sea ejecutable:

chmod +x strict_mode.sh

Ejecuta el script:

./strict_mode.sh

Deberías ver:

Starting strict mode script...
Processing input.txt and saving to output.txt
Script completed successfully

Verifica que el archivo de salida se haya creado:

cat output.txt

Deberías ver:

Processed data from input.txt

Probando el Manejo de Errores en Modo Estricto

Ahora modifiquemos nuestro script para ver cómo el modo estricto maneja los errores:

Crea un nuevo archivo llamado strict_mode_errors.sh con el siguiente contenido:

#!/bin/bash
## Strict mode
set -euo pipefail

echo "Starting script with error demonstrations..."

## Example 1: Unbound variable
echo "Example 1: About to use an unbound variable"
## Uncomment the next line to see the error
## echo "Home directory: $HOME_DIR"
echo "This line will not be reached if you uncomment the above line"

## Example 2: Command failure
echo "Example 2: About to run a failing command"
## Uncomment the next line to see the error
## grep "pattern" non_existent_file.txt
echo "This line will not be reached if you uncomment the above line"

## Example 3: Pipeline failure
echo "Example 3: About to create a failing pipeline"
## Uncomment the next line to see the error
## cat non_existent_file.txt | sort
echo "This line will not be reached if you uncomment the above line"

echo "Script completed without errors"

Haz que el script sea ejecutable:

chmod +x strict_mode_errors.sh

Ejecuta el script:

./strict_mode_errors.sh

Ahora, edita el script para descomentar una de las líneas de error (por ejemplo, la línea con $HOME_DIR), guárdalo y ejecútalo de nuevo:

./strict_mode_errors.sh

Deberías ver que el script sale inmediatamente con un mensaje de error cuando encuentra la variable no definida:

Starting script with error demonstrations...
Example 1: About to use an unbound variable
./strict_mode_errors.sh: line 9: HOME_DIR: unbound variable

Esto demuestra cómo el modo estricto ayuda a identificar problemas temprano en tu script.

Creando una Plantilla de Script Robusta

Creemos una plantilla para scripts de Bash robustos que puedas usar para futuros proyectos:

Crea un nuevo archivo llamado robust_script_template.sh con el siguiente contenido:

#!/bin/bash
## ====================================
## Robust Bash Script Template
## ====================================

## --- Strict mode ---
set -euo pipefail

## --- Script metadata ---
SCRIPT_NAME="$(basename "$0")"
SCRIPT_VERSION="1.0.0"

## --- Default configuration ---
DEBUG=${DEBUG:-false}
LOG_FILE=${LOG_FILE:-"/tmp/${SCRIPT_NAME}.log"}

## --- Helper functions ---
log() {
  local message="$1"
  local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
  echo "[$timestamp] $message" | tee -a "$LOG_FILE"
}

debug() {
  if [[ "$DEBUG" == "true" ]]; then
    log "DEBUG: $1"
  fi
}

error() {
  log "ERROR: $1"
  exit 1
}

usage() {
  cat << EOF
Usage: $SCRIPT_NAME [options]

A robust bash script template with error handling and logging.

Options:
  --help      Show this help message and exit
  --version   Show script version and exit

Environment variables:
  DEBUG       Set to 'true' to enable debug output
  LOG_FILE    Path to the log file (default: /tmp/${SCRIPT_NAME}.log)
EOF
}

## --- Process command line arguments ---
for arg in "$@"; do
  case $arg in
    --help)
      usage
      exit 0
      ;;
    --version)
      echo "$SCRIPT_NAME version $SCRIPT_VERSION"
      exit 0
      ;;
    *)
      ## Unknown option
      ;;
  esac
done

## --- Main script logic ---
main() {
  log "Starting $SCRIPT_NAME version $SCRIPT_VERSION"

  ## Your script logic goes here
  debug "Script executed with DEBUG=$DEBUG"
  log "Script executed by user: $(whoami)"
  log "Current directory: $(pwd)"

  ## Example of using a variable with default value
  TARGET_DIR=${TARGET_DIR:-$(pwd)}
  log "Target directory: $TARGET_DIR"

  log "$SCRIPT_NAME completed successfully"
}

## --- Run main function ---
main

Haz que el script sea ejecutable:

chmod +x robust_script_template.sh

Ejecuta el script:

./robust_script_template.sh

Intenta ejecutarlo con la depuración habilitada:

DEBUG=true ./robust_script_template.sh

Esta plantilla incluye:

Configuración del modo estricto para detectar errores
Configuración predeterminada con expansión de parámetros
Funciones de registro y depuración
Procesamiento de argumentos de línea de comandos
Una estructura limpia con una función principal

Puedes usar esta plantilla como punto de partida para tus propios scripts de Bash para hacerlos más robustos y mantenibles.

Creando una Aplicación del Mundo Real

Ahora que hemos aprendido sobre variables, variables no definidas, expansión de parámetros y modo estricto, combinemos todos estos conceptos en un script práctico. Crearemos una utilidad simple de copia de seguridad de archivos que demuestra las mejores prácticas para manejar variables en Bash.

Planificando Nuestro Script de Copia de Seguridad

Nuestro script de copia de seguridad:

Tomará un directorio de origen y un destino de copia de seguridad como entradas
Permitirá la configuración a través de variables de entorno o argumentos de línea de comandos
Manejará los errores con elegancia usando el modo estricto
Proporcionará comentarios útiles al usuario

Creando el Script de Copia de Seguridad

Crea un nuevo archivo llamado backup.sh con el siguiente contenido:

#!/bin/bash
## ====================================
## File Backup Utility
## ====================================

## --- Strict mode ---
set -euo pipefail

## --- Script metadata ---
SCRIPT_NAME="$(basename "$0")"
SCRIPT_VERSION="1.0.0"

## --- Default configuration ---
SOURCE_DIR=${SOURCE_DIR:-"$(pwd)"}
BACKUP_DIR=${BACKUP_DIR:-"/tmp/backups"}
BACKUP_NAME=${BACKUP_NAME:-"backup_$(date +%Y%m%d_%H%M%S)"}
EXCLUDE_PATTERN=${EXCLUDE_PATTERN:-"*.tmp"}
VERBOSE=${VERBOSE:-"false"}

## --- Helper functions ---
log() {
  if [[ "$VERBOSE" == "true" ]]; then
    echo "$(date "+%Y-%m-%d %H:%M:%S") - $1"
  fi
}

error() {
  echo "ERROR: $1" >&2
  exit 1
}

usage() {
  cat << EOF
Usage: $SCRIPT_NAME [options]

A simple file backup utility.

Options:
  -s, --source DIR      Source directory to backup (default: current directory)
  -d, --destination DIR Backup destination directory (default: /tmp/backups)
  -n, --name NAME       Name for the backup archive (default: backup_YYYYMMDD_HHMMSS)
  -e, --exclude PATTERN Files to exclude (default: *.tmp)
  -v, --verbose         Enable verbose output
  -h, --help            Show this help message and exit

Environment variables:
  SOURCE_DIR       Same as --source
  BACKUP_DIR       Same as --destination
  BACKUP_NAME      Same as --name
  EXCLUDE_PATTERN  Same as --exclude
  VERBOSE          Set to 'true' to enable verbose output
EOF
}

## --- Process command line arguments ---
while [[ $## -gt 0 ]]; do
  case $1 in
    -s | --source)
      SOURCE_DIR="$2"
      shift 2
      ;;
    -d | --destination)
      BACKUP_DIR="$2"
      shift 2
      ;;
    -n | --name)
      BACKUP_NAME="$2"
      shift 2
      ;;
    -e | --exclude)
      EXCLUDE_PATTERN="$2"
      shift 2
      ;;
    -v | --verbose)
      VERBOSE="true"
      shift
      ;;
    -h | --help)
      usage
      exit 0
      ;;
    *)
      error "Unknown option: $1"
      ;;
  esac
done

## --- Main function ---
main() {
  ## Validate source directory
  if [[ ! -d "$SOURCE_DIR" ]]; then
    error "Source directory does not exist: $SOURCE_DIR"
  fi

  ## Create backup directory if it doesn't exist
  if [[ ! -d "$BACKUP_DIR" ]]; then
    log "Creating backup directory: $BACKUP_DIR"
    mkdir -p "$BACKUP_DIR" || error "Failed to create backup directory"
  fi

  ## Full path for the backup file
  BACKUP_FILE="$BACKUP_DIR/$BACKUP_NAME.tar.gz"

  log "Starting backup from $SOURCE_DIR to $BACKUP_FILE"
  log "Excluding files matching: $EXCLUDE_PATTERN"

  ## Create the backup
  tar -czf "$BACKUP_FILE" \
    --exclude="$EXCLUDE_PATTERN" \
    -C "$(dirname "$SOURCE_DIR")" "$(basename "$SOURCE_DIR")" \
    || error "Backup failed"

  ## Check if backup was created
  if [[ -f "$BACKUP_FILE" ]]; then
    BACKUP_SIZE=$(du -h "$BACKUP_FILE" | cut -f1)
    echo "Backup completed successfully: $BACKUP_FILE ($BACKUP_SIZE)"
  else
    error "Backup file was not created"
  fi
}

## --- Run main function ---
main

Haz que el script sea ejecutable:

chmod +x backup.sh

Ejecuta el script con la configuración predeterminada:

./backup.sh

Deberías ver un mensaje confirmando que la copia de seguridad se creó correctamente.

Revisa el archivo de copia de seguridad:

ls -lh /tmp/backups/

Intenta ejecutar el script con diferentes opciones:

./backup.sh --source ~/project --destination ~/backups --name my_project_backup --verbose

Si el directorio ~/backups no existe, el script lo creará. Podrías ver un error si no tienes permisos de escritura para crear ese directorio.

Probando el Manejo de Errores en Nuestro Script de Copia de Seguridad

Probemos cómo nuestro script maneja los errores:

Intenta hacer una copia de seguridad de un directorio que no existe:

./backup.sh --source /path/that/does/not/exist

Deberías ver un mensaje de error como:

ERROR: Source directory does not exist: /path/that/does/not/exist

Intenta establecer un destino de copia de seguridad no válido (donde no tienes permisos de escritura):

./backup.sh --destination /root/backups

Deberías ver un mensaje de error que indica que el script no pudo crear el directorio de copia de seguridad.

Creando un Entorno de Prueba

Creemos un entorno de prueba para demostrar nuestro script de copia de seguridad:

Crea una estructura de directorio de prueba:

mkdir -p ~/project/test_backup/{docs,images,code}
touch ~/project/test_backup/docs/{readme.md,manual.pdf}
touch ~/project/test_backup/images/{logo.png,banner.jpg}
touch ~/project/test_backup/code/{script.sh,data.tmp,config.json}

Ejecuta el script de copia de seguridad en este directorio de prueba:

./backup.sh --source ~/project/test_backup --exclude "*.tmp" --verbose

Enumera los archivos en la copia de seguridad:

tar -tvf /tmp/backups/backup_*.tar.gz | sort

Deberías ver todos los archivos excepto aquellos que coinciden con el patrón de exclusión (*.tmp).

Este script de copia de seguridad demuestra todos los conceptos que hemos cubierto:

Establecer valores predeterminados para las variables usando la expansión de parámetros
Usar el modo estricto para detectar errores
Manejar argumentos de línea de comandos y variables de entorno
Proporcionar comentarios al usuario y mensajes de error
Validar entradas y manejar casos extremos

Con estas técnicas, puedes escribir scripts de Bash robustos que manejen variables no definidas con elegancia y proporcionen una mejor experiencia de usuario.

Resumen

En este laboratorio, has aprendido a manejar variables no definidas en scripts de Bash, una habilidad crítica para escribir scripts de shell confiables. Aquí hay un resumen de lo que has logrado:

Creaste scripts con la declaración y el uso adecuados de variables
Identificaste los problemas que las variables no definidas pueden causar en los scripts de Bash
Usaste comprobaciones condicionales para detectar variables no definidas
Aplicaste técnicas de expansión de parámetros para proporcionar valores predeterminados
Implementaste el modo estricto (set -euo pipefail) para detectar errores temprano
Creaste una plantilla de script robusta con un manejo de errores adecuado
Construiste una utilidad práctica de copia de seguridad que demuestra las mejores prácticas

Al aplicar estas técnicas, puedes escribir scripts de Bash más confiables que manejen los casos extremos con elegancia y proporcionen una mejor experiencia para los usuarios. Recuerda estos puntos clave:

Siempre considera qué sucede cuando las variables no están definidas
Usa la expansión de parámetros para los valores predeterminados
Habilita el modo estricto para scripts críticos
Valida las entradas y proporciona mensajes de error útiles
Documenta el comportamiento y los requisitos de tu script

Estas prácticas te ayudarán a crear scripts de Bash que sean más robustos, mantenibles y fáciles de usar.

¿Cómo Solucionar Problemas de Variables No Definidas en Scripts de Bash?