Apuntes — ASIR Lab

Variables y tipos

En Bash todas las variables son cadenas de texto. No hay tipado estricto.

✅ Correcto

NOMBRE="Linux"          # cadena con espacios → comillas
NUMERO=42               # número como cadena
LISTA=(uno dos tres)    # array indexado
FECHA=$(date +%Y%m%d)   # sustitución de comando

❌ Error típico de examen

NOMBRE = "Linux"    # ERROR: espacios alrededor de =
NUMERO= 42          # ERROR: espacio después de =

💡 En Bash, las asignaciones NO tienen espacios: VAR=valor

Comillas simples vs dobles

Tipo	Expande variables	Expande $(cmd)	Uso
`'cadena'`	No	No	Texto literal
`"cadena"`	Sí	Sí	Texto con variables
`cmd` / `$(cmd)`	—	Sí	Sustitución de comando

Ejemplo

NOMBRE="Ana"
echo 'Hola $NOMBRE'    # → Hola $NOMBRE   (literal)
echo "Hola $NOMBRE"    # → Hola Ana       (expande)
echo "Hoy: $(date +%d/%m/%Y)"  # → Hoy: 11/06/2026

Paso de argumentos a scripts

Variable	Significado
`$0`	Nombre del script
`$1, $2...`	Argumentos posicionales
`$#`	Número de argumentos
`$@`	Todos los argumentos (como lista)
`$*`	Todos los argumentos (como cadena)
`$?`	Código de salida del último comando
`$$`	PID del proceso actual

Funciones en Bash

✅ Sintaxis correcta

nombre_funcion() {
    echo "Hola, $1"     # $1 es el primer argumento de la función
    return 0            # código de salida
}

# Llamada:
nombre_funcion "Alumno"

💡 Las variables son globales por defecto. Usa local VAR para variables locales a la función.

Errores comunes de sintaxis en examen

Error	Correcto
`VAR = valor`	`VAR=valor`
`if [ $VAR == x ]`	`if [ "$VAR" == "x" ]`
`if [ cond ] then`	`if [ cond ]; then`
`for i in 1..10`	`for i in {1..10}`
Función sin `()`	`nombre() { ... }`

Variables: locales vs globales vs de entorno

Imagina tres niveles de "alcance". Una variable normal solo existe en tu script. Una local solo dentro de una función. Una exportada viaja también a los procesos hijos (otros programas que lances).

✅ Los tres alcances

VAR_NORMAL="visible en este script"     # local al script
export VAR_ENTORNO="la heredan los hijos" # pasa a subprocesos

funcion() {
    local SOLO_AQUI="invisible fuera"     # solo dentro de la función
    echo "$VAR_NORMAL"                    # sí la ve
}

Tipo	Se declara	Visible en…
Normal	`VAR=valor`	El script actual
Local	`local VAR=valor`	Solo la función
De entorno	`export VAR=valor`	El script y sus procesos hijos

💡 Sin export, un programa que lances desde el script NO verá tu variable. Sin local, una variable dentro de una función pisa la global del mismo nombre.

Aritmética: $(( )) frente a expr

Bash no hace cálculos "solo": A+B es texto. Para operar de verdad necesitas la expansión aritmética $(( )) (moderna y rápida) o el viejo comando expr.

✅ Recomendado: $(( ))

A=5; B=3
echo $((A + B))     # 8
echo $((A * B))     # 15
echo $((A % B))     # 2  (resto)
echo $((A ** 2))    # 25 (potencia)
((A++))             # incrementa A

❌ Errores típicos

echo $A+$B          # imprime "5+3" (¡texto!)
expr $A + $B        # OJO: los espacios son OBLIGATORIOS en expr
expr $A*$B          # ERROR: el * hay que escaparlo → expr $A \* $B

💡 Dentro de $(( )) no hace falta el $ en las variables y los espacios son opcionales. Es la forma preferida hoy en día.

Arrays: indexados y asociativos

✅ Array indexado (numérico, empieza en 0)

FRUTAS=(manzana pera platano)
echo ${FRUTAS[0]}      # manzana  (primer elemento)
echo ${FRUTAS[@]}      # todos los elementos
echo ${#FRUTAS[@]}     # 3  (cuántos hay)
FRUTAS+=(uva)          # añadir un elemento

✅ Array asociativo (clave → valor)

declare -A EDADES        # OBLIGATORIO declararlo con -A
EDADES[ana]=20
EDADES[luis]=25
echo ${EDADES[ana]}      # 20
echo ${!EDADES[@]}       # claves: ana luis
echo ${EDADES[@]}        # valores: 20 25

💡 Recorre un array con for x in "${ARR[@]}"; do ...; done. Las comillas dobles evitan que se rompan los elementos con espacios.

source vs ejecución directa · el shebang

Ejecutar un script (./script.sh) lo corre en un shell hijo: sus variables NO afectan a tu terminal. source script.sh (o . script.sh) lo ejecuta en tu mismo shell: por eso se usa para recargar ~/.bashrc.

Forma	Dónde se ejecuta	¿Afecta a mi shell?
`./script.sh`	Subshell (proceso hijo)	No
`bash script.sh`	Subshell (proceso hijo)	No
`source script.sh` / `. script.sh`	El shell actual	Sí

💡 El #!/bin/bash de la primera línea (shebang) solo importa al ejecutar con ./script.sh: le dice al sistema qué intérprete usar. Sin él, podría ejecutarse con sh y fallar en sintaxis propia de Bash (arrays, [[ ]]...).

🖥️ Bash Scripting