Creación de Plantillas de Scripts Bash Reutilizables para Mayor Eficiencia

Las plantillas de scripts Bash reutilizables te ayudan a dejar de reescribir las mismas comprobaciones de seguridad cada vez que automatizas una tarea. Una buena plantilla proporciona a tu script un manejo estricto de errores, registro predecible, ayuda de uso, análisis de argumentos y enganches de limpieza antes de agregar lógica específica del proyecto.

El objetivo no es un marco enorme. Es un pequeño punto de partida que mantiene los scripts rutinarios consistentes y más fáciles de depurar.

¿Por Qué Usar Plantillas de Scripts?

Las plantillas son útiles cuando tu equipo escribe muchos scripts pequeños para copias de seguridad, despliegues, informes, limpieza de registros o movimiento de datos. Sin una plantilla, cada script tiende a manejar errores, opciones y registro de manera ligeramente diferente.

Una plantilla reutilizable te proporciona:

• Modo estricto consistente y hábitos de citado.
• Una función usage estándar.
• Un lugar para ayudantes de registro.
• Un enganche de limpieza para archivos temporales y bloqueos.
• Análisis predecible de la línea de comandos con getopts.

Las Piezas Centrales de la Plantilla

Comienza con Bash mismo, luego activa el comportamiento estricto:

#!/usr/bin/env bash
set -euo pipefail

set -e sale en muchos fallos de comando no manejados, set -u trata las variables no establecidas como errores, y set -o pipefail captura fallos dentro de tuberías. Aún necesitas comprobaciones explícitas para fallos que esperas, pero el modo estricto captura muchos errores accidentales.

Agrega un nombre de script y un bloque de uso corto:

readonly SCRIPT_NAME="$(basename "$0")"

usage() {
    cat <<USAGE
Uso: $SCRIPT_NAME [-v] [-o directorio_salida] archivo_entrada

Opciones:
  -v              Activar registro detallado
  -o directorio_salida   Escribir salida en este directorio
  -h              Mostrar este mensaje de ayuda
USAGE
}

Usa pequeños ayudantes de registro en lugar de llamadas echo dispersas:

log_info() {
    [[ "$VERBOSE" -eq 1 ]] && printf '[INFO] %s\n' "$1"
}

die() {
    printf '[ERROR] %s\n' "$1" >&2
    exit 1
}

Si el script crea archivos temporales o archivos de bloqueo, agrega una función de limpieza temprano:

cleanup() {
    # Eliminar archivos temporales o liberar bloqueos aquí.
    :
}

trap cleanup EXIT

Análisis Seguro de Argumentos con getopts

La mayoría de las plantillas reutilizables necesitan banderas. El getopts incorporado de Bash es suficiente para opciones cortas como -v y -o directorio_salida.

VERBOSE=0
OUTPUT_DIR="."

while getopts ":vo:h" opt; do
    case "$opt" in
        v) VERBOSE=1 ;;
        o) OUTPUT_DIR=$OPTARG ;;
        h) usage; exit 0 ;;
        :) die "La opción -$OPTARG requiere un argumento" ;;
        \?) die "Opción desconocida: -$OPTARG" ;;
    esac
done
shift "$((OPTIND - 1))"

INPUT_FILE=${1:-}
[[ -n "$INPUT_FILE" ]] || { usage >&2; exit 1; }
[[ -f "$INPUT_FILE" ]] || die "Archivo de entrada no encontrado: $INPUT_FILE"

El : inicial en ":vo:h" permite que tu script maneje los argumentos de opción faltantes por sí mismo. Después del análisis, shift "$((OPTIND - 1))" elimina las opciones analizadas para que los argumentos posicionales sean más fáciles de leer.

Una Plantilla Compacta que Puedes Reutilizar

Aquí tienes un punto de partida práctico para scripts de operaciones pequeñas:

#!/usr/bin/env bash
set -euo pipefail

readonly SCRIPT_NAME="$(basename "$0")"
VERBOSE=0
OUTPUT_DIR="."

usage() {
    cat <<USAGE
Uso: $SCRIPT_NAME [-v] [-o directorio_salida] archivo_entrada
USAGE
}

log_info() {
    [[ "$VERBOSE" -eq 1 ]] && printf '[INFO] %s\n' "$1"
}

die() {
    printf '[ERROR] %s\n' "$1" >&2
    exit 1
}

cleanup() {
    :
}
trap cleanup EXIT

while getopts ":vo:h" opt; do
    case "$opt" in
        v) VERBOSE=1 ;;
        o) OUTPUT_DIR=$OPTARG ;;
        h) usage; exit 0 ;;
        :) die "La opción -$OPTARG requiere un argumento" ;;
        \?) die "Opción desconocida: -$OPTARG" ;;
    esac
done
shift "$((OPTIND - 1))"

INPUT_FILE=${1:-}
[[ -n "$INPUT_FILE" ]] || { usage >&2; exit 1; }
[[ -f "$INPUT_FILE" ]] || die "Archivo de entrada no encontrado: $INPUT_FILE"
mkdir -p "$OUTPUT_DIR"

log_info "Procesando $INPUT_FILE"
# Agrega tu lógica de script aquí.

Mantén la plantilla corta. Agrega funciones compartidas solo cuando varios scripts realmente las necesiten. Una plantilla debe eliminar el trabajo de configuración repetido, no hacer que cada script se sienta como un marco.