Manual de Bash: guía completa de scripting en Linux

Si trabajas con GNU/Linux, antes o después vas a necesitar manejarte con la terminal y con Bash. Dominar un buen manual de Bash te permite automatizar tareas, entender mejor el sistema y dejar de hacer todo a mano como si estuvieras en “modo novato” permanente.

En esta guía extensa vas a encontrar una explicación completa y práctica del lenguaje de scripting Bash: desde qué es y cómo se usa en la línea de comandos, hasta cómo escribir scripts con variables, arrays, bucles, funciones, gestión de errores, redirecciones, pipes y ejemplos reales que podrías usar mañana mismo en tu máquina.

Qué es Bash y para qué sirve realmente

Bash (Bourne Again SHell) es una shell de Unix que funciona como intérprete de órdenes. Es la capa que se sitúa entre tú y el kernel de Linux: tú escribes comandos, Bash los interpreta, los ejecuta y te devuelve resultados por pantalla.

Esta shell es la que viene por defecto en la mayoría de distribuciones GNU/Linux populares (como Debian o Ubuntu) y también está disponible en macOS. Bash es ideal como primer lenguaje de programación si ya conoces los comandos básicos de la consola y quieres automatizar tareas habituales: copias de seguridad, limpieza de ficheros temporales, informes, pequeños menús, etc.

Piensa en Bash como un lenguaje estructurado bastante sencillo, muy orientado a la administración de sistemas, que aprovecha todos los comandos ya existentes del sistema, como el comando awk. En lugar de inventar la rueda de nuevo, los scripts Bash coordinan comandos, redirecciones y condiciones para que el sistema haga el trabajo por ti.

Qué es un script de Bash y cómo se prepara

Un script de Bash no es más que un archivo de texto con una serie de instrucciones que se ejecutan de forma secuencial en la shell. Con el tiempo pueden crecer hasta parecer auténticos programas: usan bucles, funciones, variables, etc., pero todo sigue siendo texto plano.

Para que Linux reconozca que un fichero es un script ejecutable hay tres puntos clave: indicar la shell correcta, dar permisos de ejecución y nombrarlo de forma razonable, normalmente con extensión .sh.

Shebang: indicar qué intérprete usar

La primera línea del archivo debe indicar la ruta del intérprete que se va a usar. Lo habitual en Bash es:

#!/bin/bash

Esta secuencia #! es lo que se conoce como shebang (hashbang, sha-bang, etc.). Cuando ejecutas el fichero como ./script.sh, el sistema lee esa primera línea y sabe que debe lanzar /bin/bash para procesar lo que viene detrás.

Si quieres depurar un script línea a línea, puedes añadir la opción -x al shebang para que Bash vaya mostrando lo que ejecuta:

#!/bin/bash -x

Permisos de ejecución y nombre del script

Una vez escrito el fichero, hay que marcarlo como ejecutable. Normalmente se usa:

chmod 755 nombre_del_script.sh

o, de forma más directa:

chmod +x nombre_del_script.sh

Respecto al nombre, el sistema no obliga a usar ninguna extensión, pero es muy recomendable usar .sh para identificar visualmente que se trata de un script. A la hora de ejecutarlo desde la terminal, si estás en el mismo directorio, se lanza con ./nombre_del_script.sh.

Ten presente que, dentro de un script de Bash, todo lo que vaya detrás del carácter # se considera comentario, salvo la primera línea de shebang. Puedes comentar líneas enteras o poner comentarios al final de una instrucción.

Tu primer script Bash paso a paso

Para editar scripts en Linux puedes usar cualquier editor de texto: desde editores gráficos (VSCode, Atom, etc.) hasta herramientas en consola como nano, vi o vim. Lo importante es que guarde el archivo en texto plano sin caracteres raros.

Vamos a crear un script muy sencillo llamado hola.sh utilizando, por ejemplo, vim:

vim hola.sh

En el interior del fichero escribes algo tan simple como:

#!/bin/bashecho "Hola. Soy tu primer script Bash"

Aquí usamos el comando echo para mostrar un texto por pantalla. También existe printf, que permite formatear la salida con más control, muy útil para alinear columnas o dar formato a números.

Guardas el archivo (por ejemplo, en Vim usando ESC seguido de :wq) y después le concedes permisos de ejecución:

chmod 755 hola.sh

Ya puedes probarlo desde la terminal, situándote en el directorio del fichero y ejecutando:

./hola.sh

Deberías ver en pantalla la frase que has definido en el script, demostrando así que el flujo básico (shebang + permisos + ejecución) está bien configurado y que Bash está interpretando tu archivo correctamente.

Parámetros posicionales y comando shift

Los scripts suelen ser útiles cuando aceptan parámetros desde la línea de comandos. Bash ofrece variables especiales para trabajar con esos argumentos posicionales sin que tengas que hacer parsing manual.

Algunos parámetros importantes dentro del script son:

• $#: número de parámetros recibidos.
• $0: nombre (y ruta) del propio script.
• $1 ... $9: parámetros del 1 al 9.
• ${N}: parámetro en la posición N, útil si hay más de 9.
• $*: todos los parámetros (excepto $0) como una única cadena.
• $@: todos los parámetros como “array” de palabras.
• $$: PID del proceso que ejecuta el script.
• $?: código de salida del último comando ejecutado.

Cuando quieres procesar parámetros de tipo --opcion valor en cualquier orden, se hace muy cómodo utilizar el comando shift, que mueve los parámetros hacia la izquierda.

Imagina que al principio tienes $1=UNO y $2=DOS. Si llamas a shift, $1 pasa a valer lo que antes estaba en $2 y el valor antiguo de $1 se pierde. De esta manera puedes ir “consumiendo” parámetros mientras recorres la línea de comandos.

Ejemplo de script con shift y parámetros nombrados

Un patrón muy típico es ofrecer opciones tipo --nombre y --apellido en cualquier orden y procesarlas mediante un bucle while junto con case y shift. La estructura sería algo como:

#!/bin/bash
# USO: ./nombre-apellido.sh --nombre NOMBRE --apellido APELLIDO
while ]do
case "$1" in
-n|--nombre)
shift
nombre="$1"
shift
;;
-a|--apellido)
shift
apellido="$1"
shift
;;
*)
# parámetro no esperado, lo saltamos
shift
;;
esac
done
echo "Tu Nombre es: $nombre y tu Apellido es: $apellido"

Al ejecutar el script como ./nombre-apellido.sh --nombre Luis --apellido Gutierrez o invirtiendo el orden de los parámetros, la salida será la misma, porque el bucle se encarga de asignar cada valor donde corresponde sin importar la posición original.

Variables en Bash: globales, locales y texto

En Bash puedes definir variables sin necesidad de declarar tipos. Son variables no tipadas: pueden contener texto, números o incluso arrays, y el intérprete se apaña con ello.

La forma básica de asignar valores es:

VAR=5
VAR=texto
VAR='cadena literal'
VAR="cadena con variables"

Cuando usas comillas simples, el contenido se trata como texto plano; con comillas dobles, Bash interpreta variables y secuencias especiales dentro de la cadena.

Por ejemplo, en un script podrías escribir:

nombre=Luis
CALLE="Calle Larga"
Despacho=401

Más tarde, para leer su valor, antepones el símbolo $ al nombre de la variable, por ejemplo $nombre. Ten en cuenta que Bash diferencia mayúsculas y minúsculas, así que CALLE y calle no son la misma variable.

Capturar la salida de comandos en variables

Una de las cosas más potentes de Bash es que permite almacenar el resultado de un comando en una variable, sin esfuerzo. Hay dos sintaxis equivalentes:

VAR=$(comando)
VAR=`comando`

Por ejemplo, para guardar en $Usuario el usuario actual del sistema puedes usar:

Usuario=$(whoami)

Si quieres recoger tanto la salida estándar como los errores, puedes redirigir stderr hacia stdout dentro de la sustitución de comandos, de forma que todo quede en la misma variable:

Salida=$(comando 2>&1)

También es habitual concatenar variables y texto:

VarB="$V1 texto1 $V2 texto2"

O jugar con los parámetros posicionales para formar nuevas cadenas, por ejemplo:

SORTEMARAP="$3 $2 $1"

que almacenaría en SORTEMARAP los tres primeros parámetros en orden inverso.

Comillas simples vs comillas dobles

Las comillas simples ' bloquean cualquier tipo de interpretación: lo que escribas dentro se guarda tal cual. Por eso, si haces:

NONO='$3 $2 $1'

en la variable NONO se guardará literalmente $3 $2 $1, no los valores de esos parámetros. En cambio, con comillas dobles, sí se expanden las variables.

Un ejemplo clásico de concatenación interpretada sería:

VarA="En un lugar"
VarB='de la Mancha'
VarC="de cuyo nombre no quiero"
VarD=acordarme
TEXTO="$VarA $VarB $VarC $VarD"

Al hacer echo "$TEXTO" obtendrás una frase completa, demostrando que dentro de comillas dobles se sustituyen variables, pero dentro de comillas simples no.

Arrays en Bash y cómo manejarlos

Bash soporta arrays indexados (y también asociativos en versiones modernas), que son muy útiles cuando quieres trabajar con colecciones de valores sin crear mil variables sueltas.

Se pueden declarar de varias formas:

• declare ARRAY o typeset ARRAY: crean un array con espacio reservado para 9 elementos.
• declare -a Colores: declara un array sin tamaño fijo.
• Frutas=(Pera Manzana Platano): inicializa el array con esos elementos.

Para escribir en un índice concreto se usa la sintaxis ARRAY=valor, recordando que los índices empiezan en 0 y llegan hasta n-1 si el array tiene n elementos consecutivos.

Por ejemplo:

Marca="Tranqui-Cola"
COCHE="Seat"
COCHE="Opel"

Para leer valores se utiliza una notación ligeramente distinta, con llaves:

• ${ARRAY}: elemento en la posición n.
• ${ARRAY}: todos los elementos del array.
• ${#ARRAY}: número de elementos almacenados.
• ${!ARRAY}: lista de índices actualmente en uso.

Un ejemplo típico para ver un elemento concreto:

Frutas=(Pera Manzana Platano)
echo ${Frutas} # Platano

Y para listar todo el contenido:

echo ${Frutas} # Pera Manzana Platano

Ten en cuenta que es posible dejar “huecos” en un array si solo asignas ciertos índices, por lo que el número de elementos y el mayor índice usado pueden no coincidir. De ahí el interés de ${!ARRAY} para recorrer únicamente los índices existentes.

Recorrer arrays y concatenarlos

Para recorrer un array sin tropezar con índices inexistentes se suele usar un bucle for sobre la lista de índices:

for i in ${!ARRAY}
do
echo "ARRAY = ${ARRAY}"
done

También puedes unir el contenido de dos arrays en un tercero, por ejemplo:

Unix=('SCO' 'HP-UX' 'IRIX' 'XENIX')
Linux=('Debian' 'Suse' 'RedHat')
NIX=("${Unix}" "${Linux}")

Así consigues un array que contiene todos los elementos de ambos arrays originales, pudiendo listar luego ${NIX} para verlos de una tacada.

Estructuras de control en scripts Bash

Como en cualquier lenguaje de scripting, Bash ofrece condicionales, bucles y estructuras de selección múltiple que permiten controlar el flujo de ejecución.

Las formas básicas de if son:

• if
then
comandos
fi
• if
then
comandos
else
comandos_alternativos
fi
• if
then
comandos
elif
then
otros_comandos
else
comandos_por_defecto
fi

Es importante respetar bien los espacios en las comparaciones dentro de corchetes: es correcto, pero sin espacios Bash no lo interpretará bien.

Los bucles tipo for tienen dos variantes comunes:

• Estilo “lista”: for var in lista; do ...; done
• Estilo C: for ((i=0; i<5; i++)); do ...; done

Además de for, tienes while (mientras la condición sea verdadera) y until (se ejecuta hasta que la condición se cumple), útiles para bucle controlado por condición en lugar de por contador.

Para casos con muchas opciones puedes emplear case:

case $VARIABLE in
valor1)
comandos_opcion1
;;
valor2|valor3|valor4)
comandos_para_varios_valores
;;
*)
comandos_por_defecto
;;
esac

Y si quieres un pequeño menú interactivo sin complicarte, select genera automáticamente un listado de opciones numeradas:

PS3="Escoja una opcion: "
select Opcion in "Actualizar" "Listar" "Salir"
do
echo "Ha elegido: $Opcion"
if ; then
break
fi
done

Para salir de bucles o saltar iteraciones tienes:

• break: sale del bucle actual.
• break N: sale de N bucles anidados.
• continue: salta al siguiente ciclo del bucle, omitiendo el resto de comandos de la iteración actual.

Operadores lógicos, aritméticos y de texto

En condicionales puedes combinar expresiones con operadores lógicos como && (AND) y || (OR), habitualmente fuera de los corchetes:

if ||
then
# algo
fi

Para cálculo numérico, Bash soporta operadores estándar: suma +, resta -, multiplicación *, división /, módulo %, potencia **, incremento ++ y decremento --. Las formas habituales de evaluarlas son:

• $((operacion))
• $ (más antigua, pero aún soportada)

Ejemplos rápidos:

echo $((2+5)) # 7
echo $ # 3
i=1; echo $ # 2
echo $ # 9

Para comparaciones de texto se usan operadores como:

• == (igual)
• != (distinto)
• > y < para ordenar léxicamente (cuidado: en a menudo conviene escaparlos)
• -z para comprobar si una cadena es vacía
• -n para comprobar si la longitud no es cero

En comparaciones numéricas se prefieren los operadores específicos:

• -eq (igual)
• -gt (mayor que)
• -ge (mayor o igual)
• -lt (menor que)
• -le (menor o igual)
• -ne (distinto)

Bash también permite hacer operaciones sobre cadenas usando la sintaxis ${}. Por ejemplo:

• ${#cadena}: longitud.
• ${cadena:N}: subcadena desde la posición N.
• ${cadena:N:M}: M caracteres a partir de N.
• ${cadena#texto} y ${cadena%texto}: eliminar prefijos o sufijos que coincidan.
• ${cadena/texto1/texto2}: reemplazar la primera coincidencia.
• ${cadena//texto1/texto2}: reemplazar todas las coincidencias.
• ${cadena/#texto1/texto2} o ${cadena/%texto1/texto2}: reemplazar solo al principio o al final.

Comprobaciones con ficheros y permisos

En scripts de administración es muy habitual querer saber si un fichero existe, si es directorio, si tiene permisos, etc. Para eso existen operadores de prueba específicos para archivos que se usan normalmente dentro de o ]:

• -e: existe (fichero o directorio).
• -s: existe y no está vacío.
• -d: existe y es directorio.
• -f: existe y es fichero regular.
• -r: tiene permiso de lectura.
• -w: tiene permiso de escritura.
• -x: ejecutable (o accesible si es un directorio).
• -O: el usuario actual es propietario.
• -G: pertenece al grupo del usuario actual.
• -nt: es más reciente que otro fichero.
• -ot: es más antiguo que otro fichero.

Para cambiar permisos se usa el comando chmod (change mode), bien en modo numérico (como 755) o simbólico (como +x para añadir ejecución). Para cambiar el usuario propietario tienes chown, que resulta muy útil en scripts de despliegue y mantenimiento, y para sincronizar con rsync puedes automatizar transferencias eficientes entre sistemas.

Redirecciones, /dev/* y pipes

Todo programa en Linux trabaja con tres descriptores de fichero básicos: entrada estándar (stdin, 0), salida estándar (stdout, 1) y salida de errores (stderr, 2). Bash permite redirigir cualquiera de ellos hacia ficheros o dispositivos especiales.

Los operadores de redirección más típicos son:

• > fich: envía stdout (y a veces stderr si se usa a secas en algunas shells) a un fichero, sobreescribiendo su contenido.
• >> fich: añade la salida al final del fichero.
• 1> fich: redirige solo stdout.
• 2> fich: redirige solo stderr.
• 2>&1: envía stderr a donde vaya stdout.
• < fich: usa el contenido de un fichero como stdin de un comando.

Por ejemplo, para listar el contenido de un directorio y guardar el resultado en un fichero, podrías usar:

ls -1 /tmp/Carpeta1 > /tmp/lista_ficheros.txt

Si quieres diferenciar la salida normal de los errores, puedes separar cada flujo en un archivo distinto, lo que facilita mucho la depuración y el logging:

ls -1 /tmp/Carpeta1 1>/tmp/lista_ficheros.txt 2>/tmp/errores.txt

Y si directamente no te interesan los mensajes de error, siempre puedes mandarlos a /dev/null, el “agujero negro” de Unix:

ls -1 /tmp/Carpeta1 1>/tmp/lista_ficheros.txt 2>/dev/null

Un patrón muy usado para silenciar completamente la salida de un comando es:

comando >/dev/null 2>&1

En cuanto a dispositivos especiales útiles en scripts, conviene conocer:

• /dev/null: descarta todo lo que se escribe.
• /dev/random y /dev/urandom: generan números pseudo-aleatorios.
• /dev/zero: produce bytes nulos.
• /dev/full: siempre “lleno”, útil para probar errores de escritura.

Por otro lado, el operador | crea una tubería (pipe) entre procesos, pasando la salida de un comando como entrada del siguiente. Ejemplos sencillos serían:

ls -1 | sort # orden alfabético ascendente
ls -1 | sort -r # orden inverso

También puedes encadenar varias pipes, por ejemplo para obtener la resolución de pantalla actual combinando xrandr, grep y awk. Encadenar varios filtros es una forma muy poderosa de construir herramientas a medida con apenas unas líneas.

Funciones en Bash y ámbito de variables

Cuando en un script repites la misma lógica varias veces, lo natural es encapsularla en una función. En Bash se pueden definir de dos formas principales, pero en ambos casos el cuerpo va entre llaves:

• function NombreFuncion { comandos; }
• NombreFuncion() { comandos; }

Las funciones no se ejecutan automáticamente: hay que llamarlas por su nombre desde otra parte del script. En su interior, los parámetros que reciban se acceden como $1, $2, etc., igual que en un script.

Respecto al ámbito de las variables, por defecto cualquier variable definida fuera de una función es global y se puede leer y modificar dentro de ella. Si quieres que una variable solo exista dentro de una función, debes declararla con local:

function AlgoPasa {
local UNO="Texto uno"
DOS="Texto dos"
echo "Dentro de la función UNO=$UNO y DOS=$DOS"
}

En este ejemplo, UNO es local a la función y desaparece al salir, mientras que DOS es global y cualquier cambio dentro de la función se mantiene después, algo que conviene tener muy en cuenta para no pisar valores sin querer.

Códigos de salida, exit y return en Bash

Todo programa en Linux termina devolviendo un código de salida. Por convención, 0 significa que todo fue bien y cualquier valor distinto de cero indica algún tipo de error. En Bash, esa información queda disponible en la variable especial $?.

Dentro de un script, es recomendable terminar con un exit num coherente con lo que ha pasado, para que otros scripts o programas puedan actuar en consecuencia. Un ejemplo típico sería:

#!/bin/bash
RUTA="$1"
ls -l "$RUTA" 2>/dev/null
CodError=$?
if ; then
echo "Todo correcto"
else
echo "Atención: se produjo algún error"
fi
exit $CodError

Las funciones también pueden indicar si han ido bien o mal, pero en su caso se utiliza return num en lugar de exit. return solo permite números, así que si necesitas devolver texto, arrays u otro tipo de datos, tendrás que hacerlo mediante variables (habitualmente globales).

Un ejemplo sencillo: una función que toma dos palabras y las une en una variable global llamada Cadena. El script principal comprueba que se hayan pasado dos parámetros y, en caso contrario, devuelve un error.

Ejemplos prácticos de scripts Bash

Para que todo lo anterior no se quede en teoría, es muy útil ver scripts reales que resuelven problemas cotidianos en sistemas GNU/Linux. A continuación tienes varios que ilustran distintos conceptos.

Leer un fichero línea a línea

Un patrón clásico es recorrer un archivo de texto línea por línea para procesar su contenido:

#!/bin/bash
FICHERO="$1"
if ; then
while read LINEA
do
echo "$LINEA"
done < "$FICHERO"
exit 0
else
echo "Debe indicar un fichero existente"
exit 1
fi

Este tipo de estructura te permite aplicar comandos a cada línea, filtrar datos, generar informes, etc., usando un bucle while read alimentado mediante redirección de entrada.

Grabar la pantalla del escritorio en un .avi

Con herramientas como ffmpeg, xrandr y zenity (para cuadros de diálogo gráficos) se puede montar un script que inicie y detenga la grabación del escritorio principal, detectando resolución y número de monitores:

#!/bin/bash
function Inicia {
FICH=$(tempfile --suffix=.avi)
NUMMONITORES=$(xrandr | grep '*' | wc -l)
RESOLUCION=$(xrandr | grep current | awk -F "," '{print $2}' | awk -v NP=$NUMMONITORES '{print $2/NP"x"$4}')
ffmpeg -y -f x11grab -s "$RESOLUCION" -r 25 -i :0.0 "$FICH" -loglevel quiet &
}
function Finaliza {
killall -9 ffmpeg
FICH=$(ls -1tr /tmp/*avi | tail -1)
echo "Vídeo guardado en: $FICH"
}
function Ejecuta {
EJECUTANDOSE=$(ps aux | grep -i ffmpeg | grep -v grep | wc -l | awk '{print $1}')
if ; then
Finaliza
else
Inicia
fi
}
Ejecuta

Aquí se ve muy bien el uso combinado de funciones, variables globales, pipes y comandos externos, todo orquestado desde Bash.

Scripts para configurar sudo de forma segura o cómoda

En algunos entornos puede interesar automatizar la inclusión de un usuario en la configuración de sudo. Con Bash puedes generar el fichero en /etc/sudoers.d/ adecuado y copiarlo mediante su:

#!/bin/bash
# Activar sudo pidiendo contraseña en cada uso
echo "Debe proporcionar la clave de root cuando se le solicite"
echo "$USER ALL=(ALL:ALL) ALL" > /tmp/autorizado_$USER
su -c "cp /tmp/autorizado_* /etc/sudoers.d/."

Y para un modo “cómodo”, en el que no se solicite contraseña al usar sudo, bastaría con variar la línea que se escribe en el fichero temporal:

echo "$USER ALL=(ALL) NOPASSWD: ALL" > /tmp/autorizado_$USER

Este tipo de scripts demuestran lo potente y peligroso a la vez que puede ser Bash cuando toca partes sensibles del sistema, así que conviene usarlos con conocimiento.

Efecto “nieve” en la terminal con tput y arrays asociativos

Más allá de tareas serias, Bash también da juego para cosas visuales en la terminal. Usando tput para mover el cursor y colores, más arrays asociativos para seguir la posición de cada copo, puedes simular una nevada:

#!/bin/bash
LINEAS=$(tput lines)
COLUMNAS=$(tput cols)
declare -A CopoDeNieve
declare -A UltimosCopos
clear
mover_copo() {
i="$1"
if }" ] || }" = "$LINEAS" ]; then
CopoDeNieve=0
else
if }" ]; then
printf "\033}" "$i"
fi
fi
printf "\033}" "$i"
UltimosCopos=${CopoDeNieve}
CopoDeNieve=$((${CopoDeNieve}+1))
}
while :
do
i=$(($RANDOM % $COLUMNAS))
mover_copo "$i"
for x in "${!UltimosCopos}"; do
mover_copo "$x"
done
sleep 0.1
done

Este script combina arrays asociativos, bucle infinito, variables de entorno como $RANDOM y secuencias ANSI para manipular el cursor, todo coordinado desde Bash puro.

Bash en la línea de comandos: comandos básicos útiles

Además del lenguaje de scripting, en el día a día vas a usar constantemente la shell interactiva. Algunos comandos básicos que conviene dominar son pwd, cd, ls, tree, mkdir, touch, cp, mv, rm, less, cat, head, tail, hexdump y grep.

Por ejemplo, con pwd ves la ruta completa del directorio actual, con cd cambias de carpeta, y con ls listas contenido. El comando tree muestra un árbol recursivo de directorios y archivos, muy cómodo para tener una visión global de un proyecto.

Para crear cosas nuevas usas mkdir (directorios) y touch (ficheros). cp copia archivos, mv los mueve o renombra, y rm los borra. Ten mucho cuidado con rm -r y rm -rf, porque pueden eliminar directorios enteros sin marcha atrás.

Para visualizar archivos, less es muy cómodo porque permite navegar con el teclado, mientras que cat simplemente vuelca todo el contenido. head y tail muestran respectivamente el comienzo y el final de un archivo, y aceptan la opción -n para indicar cuántas líneas quieres ver.

Si trabajas con binarios o estructuras de memoria, hexdump te permite ver el contenido en hexadecimal. Para buscar texto dentro de archivos, grep es la herramienta estrella, y se integra de maravilla con pipes: por ejemplo, cat *.c | grep sleep te mostrará todas las líneas donde aparezca sleep en tus fuentes C. Para revisar logs del sistema también es útil conocer journalctl.

Variables de entorno y archivo .bashrc

Las variables de entorno son valores que se cargan en tu sesión de shell y afectan al comportamiento de programas y scripts. Puedes verlas con env o printenv, y se muestran en formato NOMBRE=valor.

Para definir una variable de entorno temporal basta con hacer:

export MI_VARIABLE='aguante sistemas operativos'

Mientras dure esa sesión (y sus shells hijas) podrás acceder a $MI_VARIABLE. Pero si cierras la terminal, desaparece. Para que se cargue automáticamente en cada nueva shell interactiva, puedes añadir el export correspondiente al final de tu fichero ~/.bashrc y abrir una nueva terminal.

El flujo típico sería: ir al home con cd ~, editar .bashrc con nano .bashrc o similar, añadir al final algo como export MI_VARIABLE='aguante sisop', guardar y cerrar. A partir de ahí, cada vez que abras una nueva consola, esa variable estará disponible sin hacer nada más.

En conjunto, dominar Bash como shell y como lenguaje de scripting te da un control muy fino sobre cualquier sistema GNU/Linux: puedes automatizar desde las tareas más tontas hasta procesos de despliegue complejos, gestionar logs, monitorizar servicios, construir pequeños menús para otros usuarios y, en definitiva, hacer que la máquina trabaje por ti en lugar de repetir comandos a mano una y otra vez.