Qué son las variables en Bash y cómo usarlas

Las variables de Bash son espacios de almacenamiento con un nombre asociado que guardan valores para poder consultarlos y manipularlos desde la línea de comandos de Linux. En los scripts de shell, permiten trabajar con información dinámica, como rutas de archivos, ajustes de configuración o resultados de comandos, sin tener que escribir esos datos directamente en el código.

Esto es lo que necesitas saber sobre las variables de Bash:

• Asignación de variables de Bash. Usa el formato clave=valor sin espacios a ambos lados del signo igual. Si un valor contiene espacios, escríbelo entre comillas.
• Tipos de variables de Bash. Puedes definir tus propias variables para usarlas en un script o una sesión de shell, o variables de entorno que los procesos secundarios pueden heredar.
• Ámbito de las variables de Bash. El ámbito determina desde dónde se puede acceder a una variable. Por defecto, las variables son globales dentro de un script, pero puedes usar la palabra clave local para limitar su ámbito a una función concreta.
• Variables especiales de Bash. Usa variables como $0, $$ y $? para obtener automáticamente datos como el nombre del script, identificadores de procesos y códigos de salida.
• Exportación y eliminación de variables. Exporta variables para que estén disponibles en los procesos secundarios que se inicien desde el shell. Para eliminarlas, usa unset.
• Uso de comillas y sustitución de comandos. Usa las comillas y la sustitución de comandos para controlar cómo se interpretan los valores. Las comillas simples conservan el texto literalmente, mientras que las dobles permiten expandir variables. La sintaxis $(comando) permite capturar el resultado de un comando.
• Usos habituales de las variables de Bash. Combina las variables de Bash con condicionales, bucles y arrays para trabajar con datos dinámicos, algo especialmente útil para automatizar tareas.

Antes de ver estos usos en detalle, vamos a empezar por lo básico: cómo asignar valores a las variables de Bash.

Cómo asignar valores a variables en Bash

Para asignar un valor a una variable de Bash, debes usar el operador de asignación (=) para asociar un nombre con un valor.

La regla más importante es no dejar espacios a ambos lados del operador de asignación.

Si los añades, el shell interpretará el nombre de la variable como un comando y no como una asignación, lo que provocará un error.

La asignación directa es la forma más básica de definir una variable y consiste en asociar un valor directamente con su nombre. Suele utilizarse para definir valores fijos o rutas de configuración que no necesitan calcularse de forma dinámica.

#!/bin/bash

server_name=Apache-01

echo $server_name

Por defecto, Bash trata los valores numéricos como cadenas de caracteres. Sin embargo, puede interpretarlos como enteros en determinados contextos aritméticos, como las expresiones entre paréntesis dobles ((( ))) o al usar el comando expr.

#!/bin/bash

initial_value=10

(( result = initial_value + 5 ))

echo $result

Si quieres asignar valores que contengan espacios o caracteres especiales, usa comillas. De lo contrario, Bash puede interpretar las distintas partes del valor por separado.

Al escribir el texto entre comillas, te aseguras de que el shell trate toda la secuencia como un único valor.

#!/bin/bash

error_msg="Archivo no encontrado"

echo $error_msg

Para que Bash interprete correctamente las variables, también debes respetar determinadas reglas al nombrarlas.

Los nombres solo pueden contener caracteres alfanuméricos y guiones bajos, y no pueden empezar por un número. Además, Bash distingue entre mayúsculas y minúsculas, por lo que PATH, Path y path son tres variables distintas.

Tipos de variables en Bash

Según su función y quién puede acceder a ellas, las variables de Bash se dividen en dos tipos: variables definidas por el usuario y variables de entorno.

Qué son las variables definidas por el usuario

Las variables definidas por el usuario permiten almacenar datos temporales en un script de Bash o durante una sesión de terminal. Pertenecen al proceso que las ha creado y solo existen mientras se ejecuta el script o permanece activa la sesión correspondiente.

Para crearlas, basta con asignar un valor a un nombre nuevo. Por ejemplo:

#!/bin/bash

app_dir="/var/www/html"

echo "Desplegando en: $app_dir"

En este ejemplo de script de Bash, la variable app_dir está disponible en el proceso que ejecuta el script, pero los procesos secundarios no la heredan a menos que se exporte.

Qué son las variables de entorno

En Bash, las variables de entorno contienen valores que los procesos secundarios iniciados desde el shell pueden heredar. No están disponibles automáticamente para otros usuarios ni para los programas que ya están en ejecución.

Puedes convertir una variable del shell en una variable de entorno con el comando export. Por convención, los nombres de estas variables suelen escribirse en mayúsculas. Por ejemplo:

export VAR=value

Si después ejecutas un script como proceso secundario desde ese mismo shell, heredará automáticamente el valor de VAR:

#!/bin/bash

echo "$VAR"

Estos son algunos ejemplos de variables de entorno de Bash:

Para consultar las variables de entorno de tu sistema, usa el comando printenv. Si quieres consultar el resultado cómodamente página por página, puedes pasarlo a less:

printenv | less

Cómo funciona el ámbito de las variables en Bash

El ámbito de una variable determina desde dónde se puede acceder a ella o modificarla. Controlarlo evita, por ejemplo, que una variable definida dentro de una función modifique por accidente otra variable con el mismo nombre en el script principal.

Por defecto, las variables declaradas en un script son globales dentro de ese script, por lo que también puedes acceder a ellas y modificarlas desde las funciones. Para limitar una variable a una función y evitar que modifique otra global con el mismo nombre, usa la palabra clave local.

Por ejemplo, el siguiente script contiene dos variables llamadas status. La variable global tiene el valor Processing, mientras que la variable local de la función update_status() tiene asignado el valor Done:

#!/bin/bash

# Global variable

status="Processing"

update_status() {
    # Local variable with the same name
    local status="Done"
    echo "Inside function: $status"
}

echo "Before function: $status"

update_status

echo "After function: $status"

Fuera de la función, status conserva el valor global Processing. Dentro de update_status(), en cambio, la variable local con el mismo nombre tiene el valor Done.

Cómo funcionan las variables especiales en Bash

Bash incluye un conjunto de parámetros especiales cuyos valores se actualizan automáticamente según el script, sus argumentos y el estado de los procesos. En lugar de asignarles valores manualmente, puedes consultarlos para obtener información dinámica durante la ejecución.

Estos parámetros proporcionan información sobre el script y sus argumentos:

• $0 representa el nombre del archivo del script que se está ejecutando.
• $# indica el número total de argumentos que se han pasado al script.
• $@ se expande a todos los argumentos del script y, al usarse entre comillas dobles, conserva cada uno como un argumento independiente.
• $* se expande a todos los argumentos del script y, al usarse entre comillas dobles, los trata como una única cadena.

Otros permiten consultar información sobre los procesos y el estado de ejecución:

• $$ muestra el identificador de proceso (PID) del shell actual.
• $! muestra el PID del último proceso iniciado en segundo plano.
• $? indica el código de salida del último comando ejecutado. Por convención, 0 indica que el comando se ha ejecutado correctamente, mientras que un valor distinto de 0 suele indicar un error.
• $_ contiene el último argumento del comando anterior.
• $- muestra las opciones activas del shell.

Por ejemplo, este script utiliza variables especiales para mostrar su propio nombre, el identificador del proceso y el código de salida de un comando.

#!/bin/bash

echo "Nombre del script: $0"
echo "PID actual: $$"

# Intenta mostrar un archivo inexistente para generar un error
ls /dummy_file 2>/dev/null

# Muestra el código de salida del comando anterior
echo "Código de salida (0 = correcto, distinto de 0 = error): $?"

Los valores no están escritos directamente en el código. Bash los obtiene de forma dinámica según el script y el estado de ejecución.

Cómo exportar y eliminar variables en Bash

Las variables definidas en un shell no se transmiten automáticamente a los procesos secundarios, como scripts o nuevos shells iniciados desde el shell actual.

Si quieres que una variable del shell actual esté disponible para los procesos secundarios que se inicien después, usa el comando export. Por ejemplo, este script exporta API_KEY e inicia un nuevo shell de Bash que puede acceder a su valor:

#!/bin/bash

# Define and export a variable

export API_KEY="12345-ABCDE"

# Start a new child shell instance and print the variable

bash -c 'echo "Child shell sees: $API_KEY"'

En un caso real, un script puede iniciar varios procesos secundarios y no todos tienen por qué necesitar una variable exportada. Por ejemplo, puede que tengas que pasar una contraseña o un token a un proceso concreto, pero que las operaciones posteriores ya no necesiten ese dato.

Para eliminar una variable del shell actual y evitar que los procesos secundarios que se inicien después la hereden, usa el comando unset:

#!/bin/bash

# Define and export a variable

export API_KEY="12345-ABCDE"

# Start a new child shell instance and print the variable

bash -c 'echo "Child shell sees: $API_KEY"'

# Remove variable from the memory for subsequent processes

unset API_KEY
echo "Parent shell after unset: $API_KEY"
bash -c 'echo "Child shell sees: $API_KEY"'

En este ejemplo, el primer proceso secundario puede acceder al valor de la variable. Después de ejecutar unset, la variable se elimina del shell actual y los procesos secundarios que se inicien a partir de ese momento ya no podrán heredarla.

Cómo usar comillas y sustitución de comandos en Bash

Bash permite controlar cómo interpreta el contenido de una cadena mediante distintos tipos de comillas y la sustitución de comandos.

Cuándo usar comillas simples y dobles

Las comillas simples (‘ejemplo‘) hacen que todos los caracteres de su interior, incluido $, se interpreten literalmente.

Por ejemplo, el siguiente script muestra $HOME en lugar de su valor porque está escrito entre comillas simples:

#!/bin/bash

echo 'The value is $HOME'

# Output: The value is $HOME

Las comillas dobles (“ejemplo”) permiten expandir variables y realizar sustituciones de comandos dentro de una cadena. Por ejemplo, el siguiente script muestra el valor de $HOME en lugar de imprimir $HOME como texto literal:

#!/bin/bash

echo "The value is $HOME"

# Output: The value is /root

Cómo usar la sustitución de comandos

La sustitución de comandos permite guardar el resultado de un comando en una variable. Para usarla, escribe el comando dentro de $( ):

#!/bin/bash

backup_file="data_$(date +%F).tar.gz"

echo "Backing up to: $backup_file"

Este script ejecuta date +%F e incorpora su resultado al valor de la variable backup_file.

En scripts antiguos, puedes encontrar comandos escritos entre acentos graves (ejemplo). Sin embargo, esta sintaxis ya no se recomienda porque dificulta el anidamiento de comandos.

Ejemplos de variables en Bash

Puedes combinar las variables de Bash con otros elementos de Bash para trabajar con datos dinámicos y controlar el comportamiento de tus scripts.

Por ejemplo, puedes usarlas con operaciones aritméticas y sentencias if:

#!/bin/bash

count=3
if (( count > 2 )); then
    echo "Count is greater than 2"
fi

La variable count almacena un número y el condicional usa su valor para decidir si debe ejecutar el comando echo. Así, el script puede tomar decisiones en función de los datos almacenados en una variable.

Las condiciones de una sentencia if también pueden escribirse entre dobles corchetes. Por ejemplo, este script muestra un mensaje si el valor de la variable termina en .txt:

#!/bin/bash

file="report.txt"
if [[ $file == *.txt ]]; then
    echo "It is a text file"
fi

En las asignaciones de variables no debe haber espacios a ambos lados del signo igual. En cambio, debes dejar espacios después de [[ y antes de ]] en las expresiones condicionales. Confundir ambas reglas puede provocar errores de sintaxis.

Además de utilizarlas con sentencias if, también puedes almacenar arrays de Bash en variables y recorrer fácilmente sus elementos dentro de un script. Por ejemplo:

#!/bin/bash

nums=(1 2 3)

for n in "${nums[@]}"; do
    echo "$n"
done

Este script define un array de números, recorre sus elementos mediante un bucle for y pasa cada uno al comando echo.

Al trabajar con arrays, las llaves permiten delimitar correctamente el nombre de la variable en expresiones como ${nums[@]}. También resultan útiles cuando quieres añadir texto inmediatamente después del valor de una variable, como en este ejemplo:

dirpath="/var/www/site"

backup="${dirpath}_backup"

Sin las llaves, Bash interpretaría $dirpath_backup como una variable llamada dirpath_backup, en lugar de combinar el valor de dirpath con _backup para obtener /var/www/site_backup.

Otro error habitual es no escribir las expansiones de variables entre comillas cuando su valor debe tratarse como un único argumento. La forma recomendada en este caso sería:

var="Value of the var"

echo "$var"

Si usas $var sin comillas en un contexto en el que Bash realiza separación de palabras, un valor con espacios puede convertirse en varios argumentos. Por ejemplo, echo $var puede recibir Value, of, the y var como argumentos independientes, mientras que echo “$var” recibe el valor completo como un único argumento.

Cómo crear scripts con variables en Bash

Las variables de Bash son fundamentales para crear scripts flexibles y automatizados. Puedes almacenar en ellas nombres de archivos, datos introducidos por el usuario o listas de elementos y usar esos valores para automatizar tareas de administración de servidores Linux.

Por ejemplo, puedes guardar la ruta de un directorio en una variable, recorrer todos los archivos que contiene y realizar una acción con cada uno, como moverlos, cambiarles el nombre o crear un backup.

También puedes guardar los datos introducidos por el usuario en una variable y tomar decisiones en función de ellos, como elegir qué servicio reiniciar o qué archivo procesar.

Las variables también pueden almacenar arrays, lo que permite trabajar con varios elementos sin tener que escribir cada valor directamente en el código.

Además, puedes combinar los valores de varias variables o añadirles cadenas de texto, algo útil al trabajar con datos dinámicos como los resultados de comandos. Para obtener más información, consulta nuestra guía sobre cómo concatenar cadenas en Bash.

Todo el contenido de los tutoriales en este sitio web está sujeto a los rigurosos estándares y valores editoriales de Hostinger.

El autor

Faradilla Ayunindya

Add Hostinger as a preferred source on Google

Faradilla, or Ninda, is a Content Marketing Specialist with a passion for technology, a curiosity for digital marketing trends, and a love for languages. When she's not writing Hostinger tutorials, you can find her learning about life sciences. Follow her on LinkedIn.

Más de Faradilla Ayunindya