Imprimir variable Shell: Guía para mostrar valores en scripts

Introducción

El scripting de shell es una herramienta poderosa para automatizar tareas en entornos Linux. Una de las habilidades fundamentales en la programación de shell es trabajar con variables: ubicaciones de almacenamiento temporales que contienen datos. Este tutorial le guiará a través del proceso de creación de variables e impresión de sus valores en scripts de shell. Al final de este laboratorio, comprenderá cómo declarar variables, acceder a sus valores e incorporarlas en scripts de shell prácticos.

Creando tu Primer Script de Shell con Variables

Comencemos creando un script de shell simple que demuestre cómo declarar y usar variables.

¿Qué son las Variables de Shell?

Las variables de shell son ubicaciones de almacenamiento con nombre que pueden contener valores en scripts de shell. Permiten almacenar y recuperar datos como cadenas de texto, números, rutas de archivos y salidas de comandos. Las variables hacen que sus scripts sean más flexibles y reutilizables.

Creando tu Primer Script

Creemos un archivo de script de shell:

Abre la terminal de WebIDE
Navega al directorio del proyecto (si aún no estás allí):
```
cd ~/project
```

Crea un nuevo archivo llamado myscript.sh usando el editor de WebIDE:

Haz clic en el icono "Nuevo Archivo" en WebIDE
Nómbralo myscript.sh
Agrega el siguiente contenido al archivo:

#!/bin/bash

## Este es mi primer script de shell con variables

## Declarando una variable
name="LabEx User"

## Imprimiendo la variable
echo "Hello, $name!"

## Imprimiendo la fecha actual usando una variable
current_date=$(date)
echo "Today is: $current_date"

Guarda el archivo presionando Ctrl+S o haciendo clic en Archivo > Guardar
Haz que el script sea ejecutable con el siguiente comando:
```
chmod +x myscript.sh
```
Ejecuta tu script:
```
./myscript.sh
```

Deberías ver una salida similar a esta:

Hello, LabEx User!
Today is: Thu Jul 13 10:30:45 UTC 2023

Entendiendo el Script

Desglosemos lo que sucedió en nuestro script:

La primera línea #!/bin/bash (llamada shebang) le dice al sistema que use el shell Bash para ejecutar el script.
Creamos una variable llamada name y le asignamos el valor "LabEx User" usando name="LabEx User".
Imprimimos el valor de la variable usando echo "Hello, $name!". El símbolo $ antes del nombre de la variable le dice al shell que sustituya el valor de la variable.
Creamos otra variable current_date y le asignamos la salida del comando date usando $(date).
Imprimimos el valor de la variable current_date.

Reglas de Nombres de Variables

Al crear variables en scripts de shell, sigue estas convenciones de nomenclatura:

Los nombres de las variables pueden contener letras, números y guiones bajos
Deben comenzar con una letra o un guion bajo
No se permiten espacios alrededor del signo igual al asignar valores
Los nombres de las variables distinguen entre mayúsculas y minúsculas (NAME, name y Name son tres variables diferentes)

Intenta modificar el script para incluir tus propias variables y ejecútalo de nuevo para ver los resultados.

Diferentes Formas de Imprimir Valores de Variables

Ahora que entiendes los conceptos básicos de la creación de variables, exploremos diferentes métodos para imprimir sus valores en scripts de shell.

Usando Comillas Dobles

La forma más común de imprimir variables es usando comillas dobles con el comando echo. Las comillas dobles permiten que el shell interprete los nombres de las variables y sustituya sus valores.

Crea un nuevo archivo llamado print_variables.sh:

Haz clic en el icono "Nuevo Archivo" en WebIDE
Nómbralo print_variables.sh

Agrega el siguiente contenido:

#!/bin/bash

## Declarando variables
name="LabEx"
version=1.0
is_active=true

## Imprimiendo variables con comillas dobles
echo "Application name: $name"
echo "Version: $version"
echo "Active status: $is_active"

## Imprimiendo múltiples variables en una sola declaración
echo "The $name application version $version is $is_active"

Guarda el archivo (Ctrl+S o Archivo > Guardar)
Hazlo ejecutable:
```
chmod +x print_variables.sh
```
Ejecuta el script:
```
./print_variables.sh
```

Deberías ver una salida similar a:

Application name: LabEx
Version: 1.0
Active status: true
The LabEx application version 1.0 is true

Usando Llaves Rizadas

A veces, necesitas ser más preciso sobre dónde comienza y termina el nombre de una variable. Las llaves rizadas ayudan con esto al delinear claramente el nombre de la variable.

Agrega las siguientes líneas a tu script print_variables.sh:

## Usando llaves rizadas para definir claramente los límites de la variable
app="${name}App"
echo "Application full name: $app"

## Esto evita la confusión cuando quieres agregar texto directamente al valor de una variable
echo "Application name with text: ${name}Text"

Guarda y ejecuta el script de nuevo:

./print_variables.sh

La salida adicional debería mostrar:

Application full name: LabExApp
Application name with text: LabExText

Usando Comillas Simples

A diferencia de las comillas dobles, las comillas simples evitan la sustitución de variables e imprimen el texto literal.

Agrega estas líneas a tu script:

## Usando comillas simples (sin sustitución de variables)
echo 'With single quotes: $name is not replaced'

## Mezclando tipos de comillas para una salida compleja
echo "This is the variable value: '$name'"

Guarda y ejecuta el script de nuevo. Deberías ver:

With single quotes: $name is not replaced
This is the variable value: 'LabEx'

Usando printf para Salida Formateada

El comando printf ofrece más control sobre el formato de tu salida:

## Usando printf para salida formateada
printf "Name: %s\nVersion: %.1f\n" "$name" "$version"

## Formateando números con printf
number=42.5678
printf "Formatted number: %.2f\n" $number

Guarda y ejecuta el script de nuevo. La salida adicional mostrará:

Name: LabEx
Version: 1.0
Formatted number: 42.57

Intenta experimentar con los diferentes métodos de impresión para ver cuáles funcionan mejor para tus necesidades.

Creando un Script de Shell Práctico con Entrada del Usuario

Ahora, creemos un script de shell más práctico que tome la entrada del usuario, la almacene en variables y muestre los resultados.

Leyendo la Entrada del Usuario

El comando read permite que tu script acepte la entrada de los usuarios. Creemos un script de saludo simple:

Crea un nuevo archivo llamado greeting.sh:

Haz clic en el icono "Nuevo Archivo" en WebIDE
Nómbralo greeting.sh
Agrega el siguiente contenido:

#!/bin/bash

## Script de saludo simple que toma la entrada del usuario

## Pregunta al usuario por su nombre
echo "What is your name?"
read username

## Pregunta por la edad
echo "How old are you?"
read age

## Muestra un saludo con la información proporcionada
echo "Hello, $username! You are $age years old."

## Calcula el año de nacimiento (aproximadamente)
current_year=$(date +%Y)
birth_year=$((current_year - age))

echo "You were born around the year $birth_year."

## Agregando un mensaje personalizado basado en la edad
if [ $age -lt 18 ]; then
  echo "You are a minor."
elif [ $age -ge 18 ] && [ $age -lt 65 ]; then
  echo "You are an adult."
else
  echo "You are a senior."
fi

Guarda el archivo (Ctrl+S o Archivo > Guardar)
Hazlo ejecutable:
```
chmod +x greeting.sh
```
Ejecuta el script:
```
./greeting.sh
```
Cuando se te solicite, ingresa tu nombre y edad. Deberías ver una salida personalizada basada en tu entrada.

Entendiendo los Componentes del Script

Desglosemos las partes clave de este script:

El comando read almacena la entrada del usuario en variables (username y age).
Usamos las variables en las declaraciones echo para crear una salida personalizada.
Realizamos aritmética usando la sintaxis $((expression)) para calcular el año de nacimiento.
Usamos declaraciones condicionales (if, elif, else) para proporcionar diferentes mensajes basados en el valor de la edad.
Utilizamos el comando date con opciones de formato para obtener el año actual.

Haciendo el Script Más Interactivo

Mejoremos nuestro script para hacerlo más interactivo y útil. Agrega lo siguiente a tu archivo greeting.sh:

## Pregunta si el usuario quiere ver la información actual del sistema
echo "Would you like to see some system information? (yes/no)"
read response

## Convierte la respuesta a minúsculas para una comparación más fácil
response_lower=$(echo "$response" | tr '[:upper:]' '[:lower:]')

if [ "$response_lower" = "yes" ] || [ "$response_lower" = "y" ]; then
  echo "System information for user $username:"
  echo "-------------------------------------"
  echo "Hostname: $(hostname)"
  echo "Kernel version: $(uname -r)"
  echo "System uptime: $(uptime -p)"
  echo "CPU information: $(grep "model name" /proc/cpuinfo | head -1 | cut -d: -f2 | sed 's/^[ \t]*//')"
  echo "Memory available: $(free -h | grep Mem | awk '{print $7}')"
  echo "-------------------------------------"
else
  echo "No problem, $username. Have a great day!"
fi

Guarda el archivo y ejecútalo de nuevo:

./greeting.sh

Sigue las indicaciones e ingresa "yes" cuando se te pregunte si quieres ver la información del sistema. Deberías ver información detallada sobre el sistema.

Este script demuestra cómo:

Leer y procesar la entrada del usuario
Almacenar y manipular variables
Realizar cálculos
Tomar decisiones basadas en los valores de las variables
Ejecutar comandos del sistema y almacenar sus salidas en variables
Mostrar una salida formateada al usuario

Intenta modificar el script para agregar más funciones interactivas o diferentes tipos de información del sistema.

Creando un Script de Shell para Operaciones con Archivos

Apliquemos nuestro conocimiento de las variables de shell para crear un script útil que realice operaciones con archivos. Este script demostrará cómo las variables pueden ayudar a automatizar tareas de gestión de archivos.

Creando un Script de Copia de Seguridad

Creemos un script que haga una copia de seguridad de los archivos en un directorio especificado:

Primero, creemos un directorio de prueba y algunos archivos de muestra con los que trabajar:

mkdir -p ~/project/test_files
echo "This is file 1" > ~/project/test_files/file1.txt
echo "This is file 2" > ~/project/test_files/file2.txt
echo "This is file 3" > ~/project/test_files/file3.txt

Ahora, crea un nuevo archivo llamado backup.sh:

Haz clic en el icono "Nuevo Archivo" en WebIDE
Nómbralo backup.sh
Agrega el siguiente contenido:

#!/bin/bash

## Un script para hacer copias de seguridad de archivos desde un directorio fuente a un directorio de copia de seguridad

## Define variables para directorios
source_dir="$HOME/project/test_files"
backup_dir="$HOME/project/backup"
date_stamp=$(date +"%Y%m%d_%H%M%S")
backup_name="backup_$date_stamp"

## Imprime el propósito del script
echo "File Backup Script"
echo "==================="
echo "Source directory: $source_dir"
echo "Backup directory: $backup_dir/$backup_name"

## Crea el directorio de copia de seguridad si no existe
if [ ! -d "$backup_dir" ]; then
  echo "Creating backup directory: $backup_dir"
  mkdir -p "$backup_dir"
fi

## Crea un directorio de copia de seguridad con marca de tiempo
mkdir -p "$backup_dir/$backup_name"

## Verifica si el directorio fuente existe
if [ ! -d "$source_dir" ]; then
  echo "Error: Source directory $source_dir does not exist!"
  exit 1
fi

## Cuenta el número de archivos en el directorio fuente
file_count=$(ls -1 "$source_dir" | wc -l)
echo "Found $file_count files in the source directory."

## Copia los archivos al directorio de copia de seguridad
echo "Copying files to backup location..."
cp -r "$source_dir"/* "$backup_dir/$backup_name"

## Verifica la operación de copia
copied_count=$(ls -1 "$backup_dir/$backup_name" | wc -l)
echo "Copied $copied_count files to the backup directory."

## Verifica si todos los archivos se copiaron correctamente
if [ "$file_count" -eq "$copied_count" ]; then
  echo "Backup completed successfully!"
else
  echo "Warning: Not all files were copied. Please check for errors."
fi

## Enumera el contenido del directorio de copia de seguridad
echo "Contents of the backup directory:"
ls -la "$backup_dir/$backup_name"

## Muestra el tamaño total de la copia de seguridad
backup_size=$(du -sh "$backup_dir/$backup_name" | cut -f1)
echo "Total backup size: $backup_size"

Guarda el archivo (Ctrl+S o Archivo > Guardar)
Hazlo ejecutable:
```
chmod +x backup.sh
```
Ejecuta el script:
```
./backup.sh
```

Deberías ver una salida que muestra el proceso de copia de seguridad, incluyendo:

Los directorios de origen y copia de seguridad
El número de archivos encontrados
Confirmación de la operación de copia
El contenido del directorio de copia de seguridad
El tamaño total de la copia de seguridad

Entendiendo el Script

Este script de copia de seguridad demuestra varios conceptos importantes:

Uso de variables: Usamos variables para almacenar rutas de directorios, marcas de tiempo y conteos
Sustitución de comandos: Usamos la sintaxis $(command) para capturar la salida de comandos en variables
Declaraciones condicionales: Usamos declaraciones if para verificar si los directorios existen
Manipulación de cadenas: Creamos un nombre de copia de seguridad único usando la marca de tiempo
Variables de ruta: Usamos $HOME para hacer referencia al directorio de inicio del usuario
Ejecución de comandos: Usamos comandos de shell como mkdir, cp y ls dentro de nuestro script
Códigos de salida: Usamos exit 1 para terminar el script con un estado de error

Mejorando el Script de Copia de Seguridad

Modifiquemos nuestro script para aceptar un directorio fuente personalizado del usuario:

Abre backup.sh en el editor

Reemplaza el contenido con lo siguiente:

#!/bin/bash

## Un script para hacer copias de seguridad de archivos desde un directorio fuente a un directorio de copia de seguridad

## Verifica si se proporcionó un directorio fuente
if [ $## -eq 0 ]; then
  ## No se proporcionó ningún argumento, usa el directorio predeterminado
  source_dir="$HOME/project/test_files"
  echo "No source directory specified, using default: $source_dir"
else
  ## Usa el directorio proporcionado
  source_dir="$1"
  echo "Using specified source directory: $source_dir"
fi

## Define variables para directorios
backup_dir="$HOME/project/backup"
date_stamp=$(date +"%Y%m%d_%H%M%S")
backup_name="backup_$date_stamp"

## Imprime el propósito del script
echo "File Backup Script"
echo "==================="
echo "Source directory: $source_dir"
echo "Backup directory: $backup_dir/$backup_name"

## Crea el directorio de copia de seguridad si no existe
if [ ! -d "$backup_dir" ]; then
  echo "Creating backup directory: $backup_dir"
  mkdir -p "$backup_dir"
fi

## Crea un directorio de copia de seguridad con marca de tiempo
mkdir -p "$backup_dir/$backup_name"

## Verifica si el directorio fuente existe
if [ ! -d "$source_dir" ]; then
  echo "Error: Source directory $source_dir does not exist!"
  exit 1
fi

## Cuenta el número de archivos en el directorio fuente
file_count=$(ls -1 "$source_dir" | wc -l)
echo "Found $file_count files in the source directory."

## Copia los archivos al directorio de copia de seguridad
echo "Copying files to backup location..."
cp -r "$source_dir"/* "$backup_dir/$backup_name"

## Verifica la operación de copia
copied_count=$(ls -1 "$backup_dir/$backup_name" | wc -l)
echo "Copied $copied_count files to the backup directory."

## Verifica si todos los archivos se copiaron correctamente
if [ "$file_count" -eq "$copied_count" ]; then
  echo "Backup completed successfully!"
else
  echo "Warning: Not all files were copied. Please check for errors."
fi

## Enumera el contenido del directorio de copia de seguridad
echo "Contents of the backup directory:"
ls -la "$backup_dir/$backup_name"

## Muestra el tamaño total de la copia de seguridad
backup_size=$(du -sh "$backup_dir/$backup_name" | cut -f1)
echo "Total backup size: $backup_size"

Guarda el archivo
Ejecuta el script con un directorio personalizado:
```
./backup.sh ~/project
```

El script mejorado ahora demuestra:

Argumentos de línea de comandos usando $1 (el primer argumento pasado al script)
Valores predeterminados cuando no se proporcionan argumentos
Verificación de parámetros con $# (el número de argumentos)

Este script de copia de seguridad es un ejemplo práctico de cómo las variables de shell se pueden usar para crear herramientas útiles y flexibles para automatizar tareas de gestión de archivos.

Resumen

En este laboratorio, has aprendido las habilidades esenciales para trabajar con variables en scripts de shell:

Creación y declaración de variables de shell
Diferentes formas de imprimir valores de variables usando echo, printf y comillas
Lectura y procesamiento de la entrada del usuario
Realización de cálculos con variables de shell
Uso de variables para operaciones con archivos y tareas de copia de seguridad
Manejo de argumentos de línea de comandos

Estas habilidades forman una base sólida para la creación de scripts de shell y te permitirán crear scripts más dinámicos y flexibles para automatizar diversas tareas en un entorno Linux. A medida que continúes tu viaje en la creación de scripts de shell, puedes construir sobre estos conceptos para desarrollar scripts más complejos para la administración del sistema, la gestión de archivos y las tareas de procesamiento de datos.

¿Cómo imprimir el valor de una variable en un script de shell?

Introducción

Creando tu Primer Script de Shell con Variables

¿Qué son las Variables de Shell?

Creando tu Primer Script

Entendiendo el Script

Reglas de Nombres de Variables

Diferentes Formas de Imprimir Valores de Variables

Usando Comillas Dobles

Usando Llaves Rizadas

Usando Comillas Simples

Usando printf para Salida Formateada

Creando un Script de Shell Práctico con Entrada del Usuario

Leyendo la Entrada del Usuario

Entendiendo los Componentes del Script

Haciendo el Script Más Interactivo

Creando un Script de Shell para Operaciones con Archivos

Creando un Script de Copia de Seguridad

Entendiendo el Script

Mejorando el Script de Copia de Seguridad

Resumen