Bash para empezar

1
2
3
4
5
6
$ pwd
/home/usuario
$ ls -l
-rw-r--r-- 1 usuario usuario 4096 jul 19 10:23 archivo.txt
$ echo "Hola Mundo!"
Hola Mundo!

$ PWD
PWD: command not found

$ cd proyectos; ls; echo "Directorio explorado"

$ make && ./programa

1
2
3
4
5
6
$ cd /etc
$ pwd
/etc
$ cd ~
$ pwd
/home/usuario

$ ls -lh
-rw-r--r-- 1 usuario usuario 1.2K jul 19 10:23 notas.txt

$ mkdir proyectos
$ cd proyectos
$ touch main.c

$ cp datos.txt copia.txt
$ mv copia.txt ../backup/
$ rm -r carpeta_antigua

$ head -n 5 log.txt

ls -l > listado.txt

echo "Nueva entrada" >> listado.txt

wc -l < listado.txt

ls archivo_inexistente 2> errores.log

comando >> salida.log 2>> errores.log

ls -l | grep "\.txt"

du -sh * | sort -h

ps aux | grep firefox | awk '{print $2}'

cat archivo.txt | grep "error" > errores.txt

find /var/log -type f | xargs grep -i fail 2>/dev/null > fallas.txt

find . -name "*.txt"          # Busca archivos por nombre
grep "palabra" archivo.txt    # Busca texto en archivo
grep -r "funcion" src/        # Busca recursivamente

1
2
3
4
5
6
7
8
9
10
mi_var="Hola mundo"
echo $mi_var

# Variables de entorno
echo $HOME
echo $PATH

# Comando útil
which bash      # Ruta del ejecutable
type ls         # Muestra si es alias, función, o comando

chmod +x script.sh      # Hace ejecutable un archivo
ls -l                   # Muestra permisos

ps aux            # Lista todos los procesos
top               # Monitor en tiempo real
kill PID          # Termina un proceso por ID
&                 # Ejecuta en segundo plano
ctrl + z          # Pausa proceso (fg/bg para retomarlo)

#!/bin/bash
# Este es un comentario

echo "Hola, mundo"
date

1
2
3
4
5
6
7
8
#!/bin/bash
ORIGEN="$HOME/documentos"
DESTINO="$HOME/respaldo"
FECHA=$(date +%Y-%m-%d)

mkdir -p "$DESTINO"
cp -r "$ORIGEN" "$DESTINO/respaldo-$FECHA"
echo "Respaldo completado en $DESTINO/respaldo-$FECHA"

chmod +x script.sh
./script.sh

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# Condicional
if [ -f archivo.txt ]; then
  echo "Existe"
else
  echo "No existe"
fi

# lazo for
for archivo in *.txt; do
  echo "$archivo tiene $(wc -l < "$archivo") líneas"
done

# lazo while
while read linea; do
  echo "Línea: $linea"
done < archivo.txt

1
2
3
4
5
6
7
8
9
10
11
*.txt       # todos los .txt
?           # un solo caracter
[abc]*      # comienza con a, b o c
[0-9]*      # comienza con un dígito
[!0-9]*     # NO comienza con un dígito
**/*.py     # todos los .py recursivamente (bash 4.0+)

echo {1..5}       # 1 2 3 4 5
echo {a..d}.txt   # a.txt b.txt c.txt d.txt
echo {001..100}   # números con padding de ceros
echo archivo.{txt,md,py}  # archivo.txt archivo.md archivo.py

1
2
3
4
5
6
7
8
9
10
11
12
13
# Expansión aritmética
echo $((5 + 3))           # 8
echo $((2**3))            # 8 (potencia)

# Expansión de comandos
echo "Hoy es $(date +%A)"
echo "Archivos: $(ls | wc -l)"

# Expansión de parámetros
archivo="documento.txt"
echo "${archivo%.*}"      # documento (sin extensión)
echo "${archivo##*/}"     # documento.txt (solo nombre)
echo "${archivo:-backup}" # valor por defecto

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# wc - contar líneas, palabras, caracteres
wc -l archivo.txt         # líneas
wc -w archivo.txt         # palabras
wc -c archivo.txt         # caracteres

# sort - ordenar contenido
sort archivo.txt          # orden alfabético
sort -n numeros.txt       # orden numérico
sort -r archivo.txt       # orden inverso
sort -k2 datos.csv        # ordenar por segunda columna

# uniq - eliminar duplicados (requiere entrada ordenada)
sort archivo.txt | uniq   # elimina duplicados
sort archivo.txt | uniq -c # cuenta ocurrencias

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# grep - búsqueda de patrones
grep "patrón" archivo.txt           # busca líneas que contengan "patrón"
grep -i "patrón" archivo.txt        # búsqueda sin distinción de mayúsculas
grep -r "patrón" directorio/        # búsqueda recursiva
grep -n "patrón" archivo.txt        # muestra números de línea
grep -v "patrón" archivo.txt        # líneas que NO contengan "patrón"
grep -E "patrón1|patrón2" archivo   # expresiones regulares extendidas

# find - búsqueda de archivos
find . -name "*.txt"                # archivos .txt en directorio actual
find /home -user juan -size +1M     # archivos de juan mayores a 1MB
find . -type d -name "test*"        # directorios que empiecen con "test"
find . -mtime -7                    # archivos modificados últimos 7 días
find . -executable -type f          # archivos ejecutables

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# sed - editor de flujo
sed 's/viejo/nuevo/' archivo.txt        # reemplaza primera ocurrencia por línea
sed 's/viejo/nuevo/g' archivo.txt       # reemplaza todas las ocurrencias
sed '5d' archivo.txt                    # elimina línea 5
sed -n '10,20p' archivo.txt             # muestra líneas 10 a 20

# awk - procesamiento de texto estructurado
awk '{print $1}' datos.txt              # imprime primera columna
awk -F',' '{print $2}' datos.csv        # usa coma como separador
awk '{sum+=$3} END {print sum}' datos   # suma tercera columna
awk 'NR>1 {print $0}' archivo           # omite primera línea (header)

# cut - extraer columnas
cut -d',' -f1,3 datos.csv               # columnas 1 y 3 de CSV
cut -c1-10 archivo.txt                  # primeros 10 caracteres

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# Información básica
uname -a                    # información completa del sistema
whoami                      # usuario actual
id                          # información de usuario y grupos
uptime                      # tiempo de funcionamiento y carga
df -h                       # espacio en disco (human readable)
free -h                     # memoria RAM disponible
lscpu                       # información del procesador

# Procesos
ps aux                      # todos los procesos
ps -ef | grep nginx         # procesos específicos
top                         # monitor en tiempo real
htop                        # versión mejorada de top (si está instalada)
jobs                        # trabajos en segundo plano

1
2
3
4
5
6
7
8
9
# Control de procesos
command &                   # ejecutar en segundo plano
nohup command &            # ejecutar sin depender de la terminal
kill PID                    # terminar proceso por ID
kill -9 PID                # forzar terminación
killall nombre_proceso      # terminar por nombre
ctrl + z                   # suspender proceso (en terminal)
fg                         # traer proceso suspendido al primer plano
bg                         # enviar proceso suspendido al segundo plano

1
2
3
4
5
6
7
8
9
10
11
# Gestión de variables
export VAR="valor"          # crear/modificar variable de entorno
echo $PATH                  # mostrar PATH actual
env                         # listar todas las variables de entorno
unset VAR                   # eliminar variable

# Variables útiles
echo $HOME                  # directorio personal
echo $USER                  # nombre de usuario
echo $SHELL                 # shell actual
echo $PWD                   # directorio actual

1
2
3
4
5
6
7
8
9
10
11
# Redirección básica
comando > archivo           # sobrescribir archivo con salida
comando >> archivo          # agregar al final del archivo
comando < archivo           # usar archivo como entrada
comando 2> errores.log      # redirigir errores a archivo
comando &> todo.log         # redirigir todo (salida + errores)

# Redirección avanzada
comando 2>&1                # redirigir errores a salida estándar
comando | tee archivo.log   # mostrar en pantalla Y guardar en archivo
comando > /dev/null 2>&1    # descartar toda la salida

1
2
3
4
5
6
7
8
9
10
11
12
# Combinaciones útiles
cat archivo.log | grep ERROR | sort | uniq -c | sort -nr
# ↳ errores únicos ordenados por frecuencia

ls -la | awk '{sum+=$5} END {print "Total:", sum, "bytes"}'
# ↳ suma el tamaño total de archivos

ps aux | sort -k3 -nr | head -5
# ↳ procesos que más CPU consumen

find . -name "*.log" | xargs grep -l "ERROR"
# ↳ archivos .log que contienen "ERROR"

!!                          # repite el último comando
!n                          # repite el comando número n del historial
!grep                       # repite el último comando que comienza con "grep"
!?archivo                   # repite el último comando que contiene "archivo"
^viejo^nuevo               # reemplaza "viejo" por "nuevo" en último comando

1
2
3
4
5
6
7
8
9
10
ctrl + r                   # búsqueda inversa en el historial
ctrl + a                   # ir al inicio de la línea
ctrl + e                   # ir al final de la línea
ctrl + w                   # borrar palabra anterior
ctrl + k                   # borrar desde cursor al final
ctrl + u                   # borrar toda la línea
ctrl + l                   # limpiar pantalla (equivale a 'clear')
ctrl + c                   # interrumpir proceso actual
ctrl + d                   # cerrar terminal o EOF
ctrl + z                   # suspender proceso actual

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# Alias comunes
alias l='ls -lah'
alias gs='git status'
alias ll='ls -alF'
alias la='ls -A'
alias grep='grep --color=auto'
alias ..='cd ..'
alias ...='cd ../..'

# Funciones útiles
function mkcd() {
    mkdir -p "$1" && cd "$1"
}

function backup() {
    cp "$1" "$1.backup.$(date +%Y%m%d_%H%M%S)"
}

function extract() {
    case "$1" in
        *.tar.gz) tar -xzf "$1" ;; 
        *.zip) unzip "$1" ;; 
        *.rar) unrar e "$1" ;; 
        *) echo "Formato no soportado" ;; 
    esac
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# Metacaracteres básicos
.                          # cualquier carácter
*                          # cero o más del anterior
+                          # uno o más del anterior (ERE)
?                          # cero o uno del anterior (ERE)
^                          # inicio de línea
$                          # fin de línea
[]                         # clase de caracteres
[^]                        # negación de clase

# Ejemplos con grep
grep '^[A-Z]' archivo.txt          # líneas que empiezan con mayúscula
grep '[0-9]\\{3\}' archivo.txt      # exactamente 3 dígitos
grep -E '[0-9]{2,4}' archivo.txt   # entre 2 y 4 dígitos
grep '\\b[A-Za-z]+@[A-Za-z]+\\.[A-Za-z]+\\b' emails.txt  # emails básicos

1
2
3
4
5
6
7
8
9
10
11
# Validar formato de fecha (YYYY-MM-DD)
echo "2023-12-25" | grep -E '^[0-9]{4}-[0-9]{2}-[0-9]{2}$'

# Extraer números de teléfono
grep -E '\\([0-9]{3}\\) [0-9]{3}-[0-9]{4}' contactos.txt

# Buscar direcciones IP
grep -E '([0-9]{1,3}\\.){3}[0-9]{1,3}' logs.txt

# Encontrar URLs
grep -E 'https?://[A-Za-z0-9.-]+\\.[A-Za-z]{2,}' texto.html

1
2
3
4
5
6
7
8
# Nunca hagas esto (¡puede destruir el sistema!)
sudo rm -rf /              # elimina TODO el sistema
:(){ :|:& };:              # fork bomb - puede colapsar el sistema

# Uso responsable de sudo
sudo -l                    # ver permisos de sudo
sudo -u usuario comando    # ejecutar como otro usuario
sudo !!                    # ejecutar último comando con sudo

1
2
3
4
5
6
7
8
9
10
# Entender permisos (rwx para owner, group, others)
ls -l archivo.txt          # -rw-r--r-- significa rw-/r--/r--
chmod 755 script.sh        # rwxr-xr-x (ejecutable para owner)
chmod u+x archivo          # agregar ejecución para owner
chmod go-w archivo         # quitar escritura para group y others
chown usuario:grupo archivo # cambiar propietario

# Umask - permisos por defecto
umask 022                  # archivos nuevos: 644, directorios: 755
umask 077                  # archivos nuevos: 600, directorios: 700

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#!/bin/bash
# Ejemplo de script seguro

# Validar argumentos
if [ $# -lt 1 ]; then
    echo "Uso: $0 <archivo>"
    exit 1
fi

archivo="$1"

# Validar que el archivo existe
if [ ! -f "$archivo" ]; then
    echo "Error: El archivo '$archivo' no existe"
    exit 1
fi

# Validar permisos de lectura
if [ ! -r "$archivo" ]; then
    echo "Error: No se puede leer '$archivo'"
    exit 1
fi

echo "Procesando archivo seguro: $archivo"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#!/bin/bash
# Script con buenas prácticas

# Configuración estricta
set -euo pipefail  # salir en error, variables no definidas, errores en pipes

# Variables de configuración
readonly SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
readonly TEMP_DIR="/tmp/mi_script_$$"
readonly LOG_FILE="${SCRIPT_DIR}/mi_script.log"

# Función de limpieza
cleanup() {
    local exit_code=$?
    [ -d "$TEMP_DIR" ] && rm -rf "$TEMP_DIR"
    exit $exit_code
}
trap cleanup EXIT

# Función de logging
log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" | tee -a "$LOG_FILE"
}

# Crear directorio temporal
mkdir -p "$TEMP_DIR"

log "Script iniciado"
# ... resto del script
log "Script completado"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# Verificar comandos críticos
if ! command -v git &> /dev/null; then
    echo "Error: git no está instalado"
    exit 1
fi

# Timeout para comandos que pueden colgarse
timeout 30s wget https://ejemplo.com/archivo.zip || {
    echo "Error: Timeout en descarga"
    exit 1
}

# Retry con backoff exponencial
retry_command() {
    local max_attempts=3
    local delay=1
    local attempt=1
    
    while [ $attempt -le $max_attempts ]; do
        if "$@"; then
            return 0
        fi
        
        echo "Intento $attempt falló, reintentando en ${delay}s..."
        sleep $delay
        delay=$((delay * 2))
        attempt=$((attempt + 1))
    done
    
    return 1
}

1
2
3
4
5
6
7
8
9
10
11
# Ejecutar con traza
bash -x script.sh          # muestra cada comando antes de ejecutarlo
bash -v script.sh          # muestra líneas del script mientras las lee

# Dentro del script
set -x                     # activar modo debug
comando_a_debuggear
set +x                     # desactivar modo debug

# Variables de debugging
export PS4='+ ${BASH_SOURCE}:${LINENO}: ${FUNCNAME[0]:+${FUNCNAME[0]}(): }'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# Monitoreo de recursos
watch -n 1 'df -h'         # espacio en disco cada segundo
watch -n 2 'free -h'       # memoria cada 2 segundos
iostat 1                   # I/O cada segundo
sar -u 1 5                # CPU usage cada segundo, 5 veces

# Logs del sistema
tail -f /var/log/syslog    # seguir log del sistema en tiempo real
journalctl -f              # logs de systemd en tiempo real
dmesg | tail               # mensajes del kernel

# Análisis de red
netstat -tuln              # puertos abiertos
ss -tuln                   # versión moderna de netstat
lsof -i :80                # procesos usando puerto 80

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# Editar crontab personal
crontab -e

# Formato: minuto hora día mes día_semana comando
# * * * * * comando
# | | | | |
# | | | | +--- día de la semana (0-7, 0 y 7 = domingo)
# | | | +----- mes (1-12)
# | | +------- día del mes (1-31)
# | +--------- hora (0-23)
# +----------- minuto (0-59)

# Ejemplos
0 2 * * *    /home/user/backup.sh          # diario a las 2 AM
30 14 * * 1  /home/user/weekly.sh          # lunes a las 2:30 PM
0 0 1 * *    /home/user/monthly.sh         # primer día del mes
*/15 * * * * /home/user/monitor.sh         # cada 15 minutos

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# Script de backup automatizado
#!/bin/bash
# /home/user/scripts/backup.sh

BACKUP_DIR="/backup"
SOURCE_DIR="/home/user/documents"
DATE=$(date +%Y%m%d_%H%M%S)

mkdir -p "$BACKUP_DIR"
tar -czf "$BACKUP_DIR/backup_$DATE.tar.gz" "$SOURCE_DIR"

# Mantener solo los últimos 7 backups
find "$BACKUP_DIR" -name "backup_*.tar.gz" -mtime +7 -delete

echo "Backup completado: backup_$DATE.tar.gz"

apropos comando             # cuando no recordás el nombre exacto
whatis comando             # descripción breve de un comando
which comando              # ubicación del ejecutable
type comando               # tipo de comando (built-in, alias, función)
command -V comando         # información detallada del comando

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# Validación robusta de argumentos
validate_args() {
    if [ $# -lt 1 ]; then
        echo "Uso: $0 <arg1> [arg2]" >&2
        exit 1
    fi
}

# Detección de dependencias
check_dependencies() {
    local deps=("git" "curl" "jq")
    for dep in "${deps[@]}"; do
        if ! command -v "$dep" &> /dev/null; then
            echo "Error: $dep no está instalado" >&2
            exit 1
        fi
    done
}

# Configuración por defecto con override
CONFIG_FILE="${CONFIG_FILE:-"$HOME/.mi_script.conf"}"
VERBOSE="${VERBOSE:-false}"
DRY_RUN="${DRY_RUN:-false}"

1
2
3
4
5
6
7
8
9
10
11
$ echo "¡Felicitaciones! Ahora sos parte del club del shell avanzado."
¡Felicitaciones! Ahora sos parte del club del shell avanzado.
$ fortune | cowsay
 ________________________________
/ La terminal es el lienzo del     \
\ programador experto.             /
 --------------------------------
        \   ^__^
         \  (oo)\_______
            (__)\       )\/\n                ||----w |
                ||     ||