🐧 Manual de Linux + Scripting Bash

Guía completa de comandos y automatización con scripts

📁 Comandos Básicos de Navegación

📍

pwd

Muestra la ruta absoluta del directorio actual.

Sintaxis: pwd

En script: #!/bin/bash
CURRENT_DIR=$(pwd)
echo "Estás en: $CURRENT_DIR"

📋

Lista archivos y directorios.

Sintaxis: ls [opciones]

En script: #!/bin/bash
echo "Archivos en el directorio:"
for file in $(ls); do
echo "- $file"
done

🚶

Cambia directorio de trabajo.

Sintaxis: cd [directorio]

En script: #!/bin/bash
cd /var/log
echo "Analizando logs..."
# ... operaciones en /var/log
cd - # Volver al directorio anterior

👀 Visualización de Contenidos

🐱

cat

Muestra contenido de archivos.

Sintaxis: cat [opciones] archivo

En script: #!/bin/bash
# Leer archivo línea por línea
while IFS= read -r line; do
echo "Línea: $line"
done < archivo.txt

🔍

grep

Busca patrones en texto.

Sintaxis: grep [opciones] patrón

En script: #!/bin/bash
# Buscar errores en log
if grep -q "ERROR" app.log; then
echo "Se encontraron errores!"
fi

# Contar ocurrencias
COUNT=$(grep -c "warning" log.txt)
echo "Hay $COUNT warnings"

💾 Gestión de Archivos

📁

cp, mv, rm

Copiar, mover y eliminar archivos.

En script (backup): #!/bin/bash
# Backup de archivos
BACKUP_DIR="backup_$(date +%Y%m%d)"
mkdir -p "$BACKUP_DIR"
cp *.txt "$BACKUP_DIR/"
echo "Backup creado en: $BACKUP_DIR"

# Limpiar temporales
rm -f *.tmp
rm -rf temp/

🔎

find

Busca archivos y directorios.

En script: #!/bin/bash
# Buscar archivos Java modificados
find . -name "*.java" -mtime -7

# Eliminar archivos temporales
find /tmp -name "*.tmp" -mtime +30 -delete

# Contar archivos
COUNT=$(find . -type f | wc -l)
echo "Total archivos: $COUNT"

📜 Fundamentos de Scripting Bash

Shebang (#!)

Primera línea que indica el intérprete a usar.

Ejemplos:

Diferentes shebangs: #!/bin/bash # Bash estándar
#!/usr/bin/env bash # Más portable
#!/bin/sh # Shell POSIX
#!/usr/bin/python3 # Script Python
#!/usr/bin/perl # Script Perl

Buenas prácticas: Usa #!/usr/bin/env bash para mayor portabilidad entre sistemas.

🚀

Primer Script

Estructura básica de un script bash.

hola_mundo.sh: #!/bin/bash
# Script: hola_mundo.sh
# Descripción: Muestra un saludo
# Autor: Tu Nombre
# Fecha: $(date)

echo "¡Hola Mundo desde Bash!"
echo "Fecha: $(date)"
echo "Usuario: $USER"
echo "Directorio actual: $(pwd)"

Para ejecutar:
1. chmod +x hola_mundo.sh
2. ./hola_mundo.sh
O: bash hola_mundo.sh

💬

Comentarios

Documenta tu código para hacerlo comprensible.

Tipos de comentarios: # Comentario de una línea

: '
Comentario
multi-línea
estilo 1
'

<< 'COMMENT'
Comentario
multi-línea
estilo 2
COMMENT

# Comentario al final de línea
VARIABLE="valor" # Esto es un comentario

💰 Variables en Bash

📊

Variables

Almacenan datos para su uso en el script.

Tipo	Ejemplo	Descripción
Asignación	`NOMBRE="Juan"`	Sin espacios alrededor del =
Uso	`echo $NOMBRE`	Prefijo $ para acceder
Comillas	`MSG="Hola $NOMBRE"`	Dobles: expanden variables
Comillas simples	`MSG='Hola $NOMBRE'`	Simples: texto literal
Backticks	FECHA=`date`	Ejecuta comando (viejo)
$()	`FECHA=$(date)`	Ejecuta comando (moderno)

Ejemplo completo: #!/bin/bash
NOMBRE="Ana"
EDAD=25
SALUDO="Hola, $NOMBRE. Tienes $EDAD años."
FECHA_ACTUAL=$(date "+%Y-%m-%d %H:%M:%S")

echo "$SALUDO"
echo "Fecha: $FECHA_ACTUAL"

⚡

Variables Especiales

Variables predefinidas por el sistema.

Variable	Descripción	Ejemplo
`$0`	Nombre del script	`echo "Script: $0"`
`$1, $2, ...`	Argumentos posicionales	`echo "Arg1: $1, Arg2: $2"`
`$#`	Número de argumentos	`echo "Total args: $#"`
`$@`	Todos los argumentos	`echo "Args: $@"`
`$?`	Código de salida último comando	`ls; echo "Exit code: $?"`
`$$`	PID del proceso actual	`echo "PID: $$"`
`$!`	PID del último proceso en background	`sleep 10 &; echo "PID bg: $!"`

🗃️

Arrays

Estructuras para almacenar múltiples valores.

Uso de arrays: #!/bin/bash
# Declaración
FRUTAS=("manzana" "banana" "naranja")
NUMEROS=(1 2 3 4 5)

# Acceso
echo "Primera fruta: ${FRUTAS[0]}"
echo "Todas: ${FRUTAS[@]}"
echo "Total: ${#FRUTAS[@]}"

# Recorrer
for fruta in "${FRUTAS[@]}"; do
echo "Fruta: $fruta"
done

# Añadir elemento
FRUTAS+=("uva")

# Arrays asociativos (Bash 4+)
declare -A PERSONA
PERSONA[nombre]="Carlos"
PERSONA[edad]=30
echo "Nombre: ${PERSONA[nombre]}"

🔄 Control de Flujo

❓

If / Else

Estructuras condicionales.

Sintaxis básica: #!/bin/bash

# Forma básica
if [ condición ]; then
  # código si verdadero
fi

# Con else
if [ condición ]; then
  # código si verdadero
else
  # código si falso
fi

# Con elif
if [ "$1" = "start" ]; then
  echo "Iniciando..."
elif [ "$1" = "stop" ]; then
  echo "Deteniendo..."
else
  echo "Uso: $0 {start|stop}"
fi

⚖️

Operadores de Test

Operadores para condiciones.

Operadores comunes: # Strings
[ "$a" = "$b" ] # Igual
[ "$a" != "$b" ] # Diferente
[ -z "$a" ] # Vacío
[ -n "$a" ] # No vacío

# Números
[ "$a" -eq "$b" ] # Equal
[ "$a" -ne "$b" ] # Not equal
[ "$a" -lt "$b" ] # Less than
[ "$a" -le "$b" ] # Less or equal
[ "$a" -gt "$b" ] # Greater than
[ "$a" -ge "$b" ] # Greater or equal

# Archivos
[ -f "$file" ] # Existe archivo regular
[ -d "$dir" ] # Existe directorio
[ -e "$path" ] # Existe (archivo o dir)
[ -r "$file" ] # Lectura permitida
[ -w "$file" ] # Escritura permitida
[ -x "$file" ] # Ejecución permitida

# Lógicos
[ cond1 ] && [ cond2 ] # AND
[ cond1 ] || [ cond2 ] # OR
! [ cond ] # NOT

🔀

Case

Estructura switch para múltiples opciones.

Ejemplo case: #!/bin/bash

case "$1" in
  "start")
    echo "Iniciando servicio..."
    ;;
  "stop")
    echo "Deteniendo servicio..."
    ;;
  "restart")
    echo "Reiniciando servicio..."
    ;;
  "status")
    echo "Estado del servicio..."
    ;;
  *)
    echo "Uso: $0 {start|stop|restart|status}"
    exit 1
    ;;
esac

🔄

Bucles

For, while y until loops.

Tipos de bucles: # For tradicional
for i in 1 2 3 4 5; do
  echo "Número: $i"
done

# For con secuencia
for i in {1..5}; do
  echo "Número: $i"
done

# For estilo C
for ((i=0; i<5; i++)); do
  echo "Iteración: $i"
done

# While
COUNT=1
while [ $COUNT -le 5 ]; do
  echo "Contador: $COUNT"
  COUNT=$((COUNT + 1))
done

# Until
COUNT=1
until [ $COUNT -gt 5 ]; do
  echo "Contador: $COUNT"
  COUNT=$((COUNT + 1))
done

# Bucle infinito
while true; do
  echo "Presiona Ctrl+C para salir"
  sleep 1
done

🔧 Funciones en Bash

⚙️

Funciones

Agrupan código reusable.

Definición y uso: #!/bin/bash

# Definición
saludar() {
  echo "¡Hola $1!"
  return 0
}

# Función con valor de retorno
suma() {
  local resultado=$(( $1 + $2 ))
  echo $resultado
}

# Función que chequea errores
crear_directorio() {
  if [ -d "$1" ]; then
    echo "El directorio $1 ya existe"
    return 1
  fi
  mkdir -p "$1" && echo "Directorio creado: $1"
}

# Llamadas
saludar "Mundo"
TOTAL=$(suma 10 20)
echo "Suma: $TOTAL"
crear_directorio "/tmp/midir"
echo "Código de salida: $?"

💡 Ejercicios Prácticos de Scripting

📝 Ejercicio 1: Script de Sistema

Objetivo: Crear un script que muestre información del sistema
Requisitos:
- Muestra fecha y hora actual
- Muestra usuario actual
- Muestra espacio en disco
- Muestra memoria libre
- Guarda resultado en archivo log

# Posible solución:
#!/bin/bash
LOG="system_info_$(date +%Y%m%d).log"

echo "=== Información del Sistema ===" > $LOG
echo "Fecha: $(date)" >> $LOG
echo "Usuario: $USER" >> $LOG
echo "Hostname: $(hostname)" >> $LOG
echo "" >> $LOG
echo "=== Espacio en Disco ===" >> $LOG
df -h >> $LOG
echo "" >> $LOG
echo "=== Memoria ===" >> $LOG
free -h >> $LOG

echo "Información guardada en: $LOG"

📝 Ejercicio 2: Procesador de Archivos

Objetivo: Script que procesa archivos de texto
Requisitos:
- Recibe directorio como argumento
- Cuenta archivos .txt
- Busca palabra específica
- Crea resumen

# Posible solución:
#!/bin/bash

if [ $# -ne 1 ]; then
echo "Uso: $0 directorio"
exit 1
fi

DIR="$1"
PALABRA="error"

echo "Procesando: $DIR"
TXT_FILES=$(find "$DIR" -name "*.txt" | wc -l)
echo "Archivos .txt: $TXT_FILES"

echo "Buscando: $PALABRA"
grep -r -i "$PALABRA" "$DIR"

echo "Proceso completado"

📝 Ejercicio 3: Backup Automático

Objetivo: Script de backup con compresión
Requisitos:
- Comprime directorio
- Añade fecha al nombre
- Elimina backups antiguos
- Envía email de confirmación (opcional)

# Posible solución:
#!/bin/bash

BACKUP_DIR="/backups"
SOURCE_DIR="$HOME/importante"
RETENTION_DAYS=7

FECHA=$(date +%Y%m%d_%H%M%S)
ARCHIVO="backup_$FECHA.tar.gz"

# Crear backup
tar -czf "$BACKUP_DIR/$ARCHIVO" "$SOURCE_DIR"
echo "Backup creado: $ARCHIVO"

# Limpiar antiguos
find "$BACKUP_DIR" -name "backup_*.tar.gz" -mtime +$RETENTION_DAYS -delete
echo "Backups antiguos eliminados"

🔍 Depuración de Scripts

🐛

Depuración

Técnicas para debuggar scripts bash.

Opciones de depuración: # Ejecutar con tracing
bash -x script.sh

# Activar en el script
#!/bin/bash
set -x # Activa tracing
# código a debuggear
set +x # Desactiva tracing

# Otras opciones útiles
set -e # Sale al primer error
set -u # Error si variable no definida
set -o pipefail # Captura errores en pipes

# Combinación común
set -euo pipefail

# Mensajes de debug
echo "DEBUG: Variable X = $X" >&2

# Log detallado
exec 2> debug.log # Redirigir stderr a archivo

⭐

Buenas Prácticas

Consejos para scripts robustos.

1. Shebang: Siempre incluye #!/bin/bash
2. Comentarios: Documenta tu código
3. Validación: Chequea argumentos y permisos
4. Variables: Usa nombres descriptivos, comillas dobles
5. Funciones: Divide en funciones lógicas
6. Manejo de errores: Usa set -e y chequea $?
7. Logging: Registra operaciones importantes
8. Portabilidad: Evita características bash muy nuevas
9. Seguridad: Nunca evalúes entrada de usuario directamente
10. Testing: Prueba con diferentes casos

📚 Recursos Adicionales

📖

Recursos para Aprender

Documentación oficial:
• man bash - Manual completo de bash
• help - Ayuda de comandos built-in

Libros recomendados:
• "Bash Guide for Beginners"
• "Advanced Bash-Scripting Guide"
• "Linux Command Line and Shell Scripting Bible"

Práctica:
• Crea scripts para automatizar tareas diarias
• Modifica scripts existentes
• Participa en proyectos open source
• Resuelve ejercicios en línea