Variables en Bash: asignación, comillas, expansión y aritmética básica

Introducción

Cuando empezás a escribir scripts en Bash, una de las primeras cosas que tenés que dominar es el uso de variables. Las variables permiten guardar valores reutilizables, hacer que los scripts sean más legibles y facilitar la automatización de tareas. Sin embargo, el manejo de comillas, la expansión de variables y las operaciones aritméticas pueden generar confusiones, especialmente si venís de otros lenguajes de programación donde las reglas son distintas.

Este tutorial está dirigido a quienes ya tienen nociones básicas de la línea de comandos y quieren profundizar en la escritura de scripts Bash confiables y eficientes. Al finalizar, vas a saber:

• Cómo declarar y asignar valores a variables de forma correcta.
• Cuándo usar comillas simples, comillas dobles o ninguna.
• Cómo funciona la expansión de variables y qué caracteres especiales intervienen.
• Cómo realizar operaciones aritméticas básicas dentro de un script.
• Qué buenas prácticas seguir y qué errores comunes evitar.

Cada concepto se ilustra con ejemplos de scripts completos, incluyendo la salida esperada al ejecutarlos en una terminal típica de Linux.

Asignación de variables

Sintaxis básica

En Bash, una variable se asigna usando el operador = sin espacios alrededor. El nombre de la variable puede contener letras, números y guiones bajos, pero no puede iniciar con un número.

VARIABLE=valor

Es importante respetar la ausencia de espacios; si ponés espacios Bash interpretará el primer token como un comando y los siguientes como argumentos, lo que producirá un error.

Ejemplo 1: variable simple

#!/bin/bash
SALUDO="Hola, mundo"
echo $SALUDO

Salida esperada:

Hola, mundo

Al usar echo $SALUDO sin comillas, el shell realiza la expansión de la variable y luego divide el resultado en palabras según los caracteres IFS (por defecto, espacios, tabulaciones y saltos de línea). En este caso, como el valor no contiene espacios, la salida es la esperada.

Ejemplo 2: variable con espacios

Si el valor contiene espacios, es necesario protegerlo con comillas al asignarlo o al usarlo.

#!/bin/bash
FRASE="Bash es divertido"
echo $FRASE

Salida esperada (sin comillas en el echo):

Bash es divertido

Aunque en este ejemplo la salida parece correcta, lo que realmente sucede es que echo recibe tres argumentos separados por espacios: Bash, es y divertido. Luego los imprime con un espacio entre cada uno. En la mayoría de los casos el efecto visual es el mismo, pero en situaciones donde el número de espacios importa (por ejemplo, al pasar la variable a otro comando) puede generar problemas.

Para evitar sorpresas, siempre es buena práctica usar comillas dobles al expandir la variable:

#!/bin/bash
FRASE="Bash es divertido"
echo "$FRASE"

Salida esperada:

Bash es divertido

Ahora el shell pasa un único argumento a echo, preservando exactamente el contenido original.

Variables sin valor y variables nulas

Una variable puede estar declarada sin asignarle un valor explícito; en ese caso su valor es la cadena vacía.

#!/bin/bash
VACIA
echo "<${VACIA}>

Salida esperada:

<>

Si querés distinguir entre una variable no declarada y una variable declarada pero vacía, podés usar el parámetro ${VAR:-valor} o ${VAR:=valor} (más adelante veremos expansión).

Comillas simples vs comillas dobles

Comillas dobles: expansión permitida

Dentro de comillas dobles (") el shell realiza la expansión de variables, de comandos ($(cmd)) y de algunas secuencias de escape como o . Cualquier otro carácter se trata literalmente.

#!/bin/bash
NOMBRE="Ana"
editor="vim"
echo "Hola $NOMBRE, tu editor favorito es $editor"

Salida esperada:

Hola Ana, tu editor favorito es vim

Comillas simples: nada se expande

Las comillas simples (') impiden cualquier tipo de expansión. Todo lo que está entre ellas se interpreta exactamente como se escribe.

#!/bin/bash
NOMBRE="Ana"
editor="vim"
echo 'Hola $NOMBRE, tu editor favorito es $editor'

Salida esperada:

Hola $NOMBRE, tu editor favorito es $editor

Observá que los nombres de variable aparecen tal cual, sin ser reemplazados por sus valores.

Cuando no usar comillas

Hay situaciones en las que podés omitir las comillas si sabés que el valor no contiene caracteres especiales (espacios, comodines, etc.) y no querés que se realice división de palabras. Por ejemplo, al asignar un número entero:

#!/bin/bash
COUNT=5
TOTAL=$((COUNT * 2))
echo $TOTAL

Salida esperada:

10

Acá COUNT y TOTAL se usan sin comillas porque sabemos que son números y no habrá ambigüedad.

Comillas y caracteres especiales

Si necesitás incluir una comilla doble dentro de una cadena delimitada por comillas dobles, tenés que escaparla con una barra invertida (\). Lo mismo vale para incluir una comilla simple dentro de comillas simples (aunque es menos frecuente).

#!/bin/bash
MENSAJE="Él dijo: \"Vamos a aprender Bash\""
echo "$MENSAJE"

Salida esperada:

Él dijo: "Vamos a aprender Bash"

Si preferís usar comillas simples para evitar tener que escapar comillas dobles, podés hacer lo siguiente:

#!/bin/bash
MENSAJE='Él dijo: "Vamos a aprender Bash"'
echo "$MENSAJE"

Salida esperada (idéntica):

Él dijo: "Vamos a aprender Bash"

En este caso, las comillas simples impiden la expansión de la variable, por eso usamos comillas dobles alrededor de $MENSAJE al momento de imprimir.

Expansión de variables

Expansión básica

La forma más simple de expandir una variable es anteponerle un signo de dólar ($). Bash sustituye el nombre por su valor antes de ejecutar el comando.

#!/bin/bash
DIR=\/home\/usuario
ls $DIR

Si el valor de DIR contiene espacios, es necesario encerrar la expansión entre comillas dobles para que ls lo reciba como un solo argumento.

#!/bin/bash
DIR=\/home\/usuario\/mi carpeta
ls "$DIR"

Salida esperada ("$DIR" )

Salida esperada (asumiendo que el directorio existe):

<listado del contenido de /home/usuario/mi carpeta>

### Expansión con llaveces

Podés usar llaves }` cuando el nombre de una cadena o que una variable con valor predeterminado

Bash ofrece varios operadores de expansión que permiten proporcionar valores predeterminados, asignar valores si la variable está vacía o no está definida, y detectar errores.

- `${VAR:-valor}`: expande a `valor` si `VAR` está vacía o no está definida; de lo contrario, expande a `$VAR`.
- `${VAR:=valor}`: igual que el anterior, pero además asigna `valor` a `VAR` si estaba vacía o no definida.
- `${VAR:?mensaje}`: muestra `mensaje` de error y termina el script si `VAR` está vacía o no está definida.
- `${VAR:+valor}`: expande a `valor` solo si `VAR` está definida y no está vacía; de lo contrario, produce cadena vacía.

#### Ejemplo: uso de `:-`

```bash
#!/bin/bash
# VAR no está definida
echo "El valor de VAR es: ${VAR:-defecto}" 
# Ahora definimos VAR
VAR=personalizado
echo "El valor de VAR es: ${VAR:-defecto}" 

Salida esperada:

El valor de VAR es: defecto
El valor de VAR es: personalizado

Ejemplo: uso de :=

#!/bin/bash
# VAR no está definida
echo "Antes: VAR=${VAR:-no definida}" 
# := asigna defecto si está vacía o no definida
VAR=${VAR:=valor por defecto}
echo "Después: VAR=$VAR" 
# Segunda vez, ya tiene valor, así que no cambia
VAR=${VAR:=otro valor}
echo "Tercero: VAR=$VAR" 

Salida esperada:

Antes: VAR=no definida
Después: VAR=valor por defecto
Tercero: VAR=valor por defecto

Ejemplo: uso de :?

#!/bin/bash
# Descomentá la siguiente línea para ver el error
# REQUIRED=${VAR:?"Variable VAR no está definida"}
echo "Esta línea no se ejecutará si la variable no está definida"

Si ejecutás el script sin definir VAR y descomentás la línea, la salida será algo como:

script.sh: línea 5: VAR: Variable VAR no está definida

Ejemplo: uso de :+

#!/bin/bash
LLENADA="tiene valor"
VACIA=""
echo "LLENADA: ${LLENADA:+sí tiene valor}" 
echo "VACIA: ${VACIA:+sí tiene valor}" 

Salida esperada:

LLENADA: sí tiene valor
VACIA: 

Expansión de subcadenas

Podés extraer parte del valor de una variable usando la sintaxis ${VAR:inicio:longitud}. El índice inicia en 0.

#!/bin/bash
TEXTO="Bash scripting"
echo "Los primeros 4 caracteres: ${TEXTO:0:4}" 
echo "Desde el carácter 5, 3 caracteres: ${TEXTO:5:3}" 
echo "Desde el carácter 8 hasta el final: ${TEXTO:8}" 

Salida esperada:

Los primeros 4 caracteres: Bash
Desde el carácter 5, 3 caracteres: scr
Desde el carácter 8 hasta el final: ipting

Expansión de reemplazo de patrones

Con ${VAR/patron/replacement} podés reemplazar la primera coincidencia de patron por replacement. Usando doble barra ${VAR//patron/replacement} reemplazás todas las ocurrencias.

#!/bin/bash
FRASE="Bash es poderoso y Bash es divertido"
echo "Primera reemplazo: ${FRASE/Bash/Shell}" 
echo "Todas las reemplazos: ${FRASE//Bash/Shell}" 

Salida esperada:

Primera reemplazo: Shell es poderoso y Bash es divertido
Todas las reemplazos: Shell es poderoso y Shell es divertido

Aritmética básica en Bash

Bash soporta operaciones aritméticasenteras mediante la expansión aritmética $(( expresión )) o el builtin let. Los resultados son siempre enteros; no hay soporte nativo para punto flotante (para eso se usa bc o awk).

Expansión aritmética $(( ))

#!/bin/bash
A=10
B=3
SUMA=$((A + B))
RESTA=$((A - B))
MULTIPLICACION=$((A * B))
DIVISION=$((A / B))
MODULO=$((A % B))
echo "Suma: $SUMA"
echo "Resta: $RESTA"
echo "Multiplicación: $MULTIPLICACION"
echo "División entera: $DIVISION"
echo "Módulo: $MODULO"

Salida esperada:

Suma: 13
Resta: 7
Multiplicación: 30
División entera: 3
Módulo: 1

Incremento y decremento

Podés usar los operadores ++ y -- tanto en forma prefija como postfija.

#!/bin/bash
COUNTER=0
echo "Initial: $COUNTER" 
COUNTER=$((COUNTER + 1))   # forma explícita
echo "Después de +1: $COUNTER" 
((COUNTER++))              # usando let implícito
echo "Después de ++: $COUNTER" 
((COUNTER--))              # decremento
echo "Después de --: $COUNTER" 

Salida esperada:

Initial: 0
Después de +1: 1
Después de ++: 2
Después de --: 1

Uso de let

El builtin let evalúa una expresión aritmética y opcionalmente la asigna a una variable.

#!/bin/bash
let X=5*6
echo "X = $X" 
let "X += 4"               # nota las comillas para evitar expansión de espacios
echo "X después de +=4: $X" 

Salida esperada:

X = 30
X después de +=4: 34

Aritmética en condiciones

Las expresiones aritméticas también se usan dentro de pruebas condicionales [[ ... ]] o (( ... )).

#!/bin/bash
NUM=7
if (( NUM % 2 == 0 ));
then
    echo "$NUM es par"
else
    echo "$NUM es impar"
fi

Salida esperada:

7 es impar

Limitaciones y alternativas para punto flotante

Como Bash solo maneja enteros, si necesitás trabajar con decimales tenés que recurrir a herramientas externas como bc o awk.

#!/bin/bash
# Calculando 7/3 con bc
RESULTADO=$(echo "scale=2; 7/3" | bc)
echo "7/3 con dos decimales: $RESULTADO" 

Salida esperada:

7/3 con dos decimales: 2.33

Buenas prácticas

1. Nombrado descriptivo pero conciso: usá nombres que indiquen claramente el propósito (por ejemplo, ARCHIVO_LOG, CANTIDAD_INTENTOS). Evitá nombres genéricos como tmp o data salvo que el contexto lo haga obvio.
2. Siempre usar comillas dobles al expandir variables cuando el valor pueda contener espacios o caracteres especiales. Esto previene la división de palabras y la expansión de globs.
3. Evitar comillas simples cuando necesitás expansión; reservá las comillas simples solo para cadenas literales que no deban ser interpretadas.
4. Preferir la sintaxis $(( )) para aritmética entera; es más legible que let y no requiere comillas adicionales alrededor de la expresión.
5. Inicializar variables antes de usarlas; si una variable podría estar sin definir, usá los operadores de expansión predeterminada (:- o :=) para evitar sorpresas.
6. Commentar el código: explicá por qué se usa cierta forma de comilla o por qué se elige un operador de expansión particular. Esto ayuda a futuros mantenedores (incluyéndote a vos mismo).
7. Probá tus scripts con set -u (o #!/bin/bash -u) para que el shell abandone la ejecución si se intenta expandir una variable no definida. Así capturás errores de tipografía temprano.
8. Usá shellcheck para detectar problemas comunes de estilo y posibles bugs en tus scripts Bash.

Errores comunes

• Olvidar las comillas al usar echo $VAR cuando el valor tiene espacios: resulta en división de palabras y puede romper comandos que esperan un solo argumento.
• Confundir comillas simples y dobles: pensar que comillas simples permiten expansión de variables, lo que lleva a imprimir literalmente $VAR en lugar de su valor.
• Espacios alrededor del = en la asignación: VAR = valor provoca que Bash intente ejecutar VAR como comando con argumentos = y valor.
• Suponer que $(( )) trabaja con punto flotante: obtener resultados truncados o errores de sintaxis al intentar usar . o ,.
• No usar ${VAR:-valor} sin darse cuenta de que solo afecta la expansión, no la asignación (a menos que se use :=).
• Olvasar que las variables son sensibles a mayúsculas y minúsculas: miVar y mivar son distintas.
• Usar let sin comillas cuando la expresión contiene espacios: provoca que el shell separe la expresión en varios argumentos y falle.

Conclusión

Dominar las variables en Bash es un paso fundamental para escribir scripts potentes, mantenibles y seguros. En este tutorial viste cómo asignar valores correctamente, la diferencia entre comillas simples y dobles y cuándo cada una es apropiada, cómo se produce la expansión de variables y qué operadores nos permiten proporcionar valores predeterminados o realizar reemplazos de patrones. También exploramos la aritmética básica usando la sintaxis $(( )) y vimos sus limitaciones con números de punto flotante, mostrando alternativas como bc.

Recordá siempre proteger tus expansiones con comillas dobles, inicializar variables cuando corresponda y utilizar herramientas como shellcheck y set -u para detectar errores temprano. Con estas prácticas, tus scripts serán más robustos y menos propensos a fallas sutiles que suelen aparecer en entornos de producción.

Te animamos a practicar modificando los ejemplos proporcionados, creando tus propios scripts que combinen variables, comillas y operaciones aritméticas, y a consultar la página de manual de Bash (man bash) para profundizar en temas como arreglos asociativos, expansión de parámetros avanzada y manejo de señales. ¡A scripting!
EOF