Códigos de salida y gestión de errores

Introducción

Imagine que cada vez que pide a alguien que haga un trabajo, esa persona le entrega después una pequeña tarjeta.

• Una tarjeta verde (0) significa: «Lo hice perfectamente».
• Una tarjeta roja (1-255) significa: «Algo salió mal».

En Linux, todos los comandos hacen exactamente eso. Se denomina código de salida o estado de salida.

• 0: Éxito.
• Not 0: Error.

La mayoría de los principiantes ignora estos códigos porque normalmente no se muestran a menos que usted los solicite. Los profesionales que escriben scripts les prestan mucha atención, porque el estado de salida es una de las principales formas que tiene el shell de comunicar el éxito o el error entre comandos y scripts.

Este es un patrón fundamental del diseño de Unix: los programas pequeños se comunican entre sí mediante convenciones sencillas. El texto puede viajar por la salida estándar, mientras que el éxito o el error se comunican mediante el estado de salida. Por eso los códigos de salida son tan importantes en la automatización.

En este laboratorio aprenderá a leer estas tarjetas secretas mediante la variable $? y a detener los scripts antes de que causen problemas.

Comprobar el estado de un comando con $?

¿Cómo puede ver esta «tabla de resultados» invisible? Consulte una variable especial llamada $? justo después de ejecutar un comando.

Primero, observe un caso exitoso.

Abra el terminal y muestre sus archivos:

ls -l

Funcionó, ¿verdad? Ahora pregunte: «¿Cuál fue el resultado?».

echo $?

Debería ver 0. En la lógica de Linux, 0 es el número de errores. Cero errores significa éxito total.

Ahora provoque un error. Intente mostrar un archivo que no existe:

ls ghosts.txt

Linux mostrará un mensaje indicando que no puede encontrarlo. Vuelva a consultar el resultado:

echo $?

Verá 2. Como no es 0, indica un error.

El número exacto distinto de cero puede variar según el comando y la situación, pero por ahora la regla clave es sencilla: 0 significa éxito y cualquier otro valor significa error. Más adelante, al trabajar con scripts y herramientas, verá que algunos programas utilizan distintos códigos distintos de cero para describir diferentes tipos de problemas.

Regla crucial: $? es una memoria de corta duración. Solo recuerda la última acción que realizó. Si ejecuta ls (falla), después ejecuta echo "hello" y luego comprueba $?, verá 0 porque echo se ejecutó correctamente. Debe comprobarlo inmediatamente.

Crear un script que falle

Aquí está la zona de peligro. De forma predeterminada, un script ignora las tarjetas rojas y continúa ejecutándose.

Imagine un script que hace lo siguiente:

1. Crear una copia de seguridad.
2. Eliminar los archivos originales.

Si el paso 1 falla porque la copia de seguridad no tiene espacio, el paso 2 se ejecutará igualmente y usted lo perderá todo.

Simulemos este «script a ciegas».

Cree copy_script.sh:

nano copy_script.sh

Escriba este código. Intenta copiar un archivo inexistente y después afirma que todo salió bien.

#!/bin/bash

## Attempt to copy a ghost
cp ghost_file.txt destination.txt

## Print a happy message
echo "Script finished execution"

Guarde el archivo y salga. Después, hágalo ejecutable:

chmod +x copy_script.sh

Ejecútelo:

./copy_script.sh

Verá el mensaje de error de cp, pero después verá «Script finished execution». El script falló, ¡pero siguió adelante!

Compruebe el resultado del propio script:

echo $?

Devuelve 0. ¿Por qué? Porque el último comando (echo) se ejecutó correctamente. Este script miente: falló en su tarea principal, pero informó de un resultado exitoso al sistema.

Esta es una lección importante: un script de shell también tiene un estado de salida y, si no hace nada especial, normalmente adopta el estado de salida del último comando ejecutado. Por eso un script puede ocultar accidentalmente un error ocurrido anteriormente.

Implementar la gestión de errores

Debemos enseñar a nuestro script a detenerse ante una luz roja.

Por lo general, usamos esta estructura: «Intente ejecutar el comando X. Si el código de salida NO es 0, entre en modo de emergencia».

La sintaxis [ $? -ne 0 ] utiliza el comando test, escrito aquí con la forma de corchetes. -ne significa «distinto de» cuando se comparan números. Por tanto, el shell pregunta: «¿El estado de salida del comando anterior es distinto de cero?».

Edite el script copy_script.sh:

nano copy_script.sh

Cámbielo por lo siguiente:

#!/bin/bash

cp ghost_file.txt destination.txt

## Check if the score is NOT equal (-ne) to 0
if [ $? -ne 0 ]; then
  echo "Error: The copy operation failed!"
  exit 1
fi

echo "Script finished execution"

Cómo interpretarlo:

• if [ $? -ne 0 ]: El guardián comprueba la tarjeta.
• exit 1: El botón rojo. Detiene el script inmediatamente y establece el resultado global en 1 (error).

El comando exit finaliza el script de shell actual y devuelve ese número a quien lo inició, como su terminal, otro script o un sistema de automatización. En otras palabras, no solo detiene la ejecución localmente: también informa del estado al exterior.

Guarde el archivo y salga.

Vuelva a ejecutarlo:

./copy_script.sh

El script muestra el error y finaliza. No muestra «Script finished execution».

Compruebe el resultado:

echo $?

Es 1. Ahora el script informa honestamente de su error.

Resumen

Ha aprendido a interpretar el lenguaje secreto de los comandos.

En este laboratorio practicó lo siguiente:

1. Leer las tablas de resultados: usar $? para comprobar si un comando tuvo éxito (0) o falló (1-255).
2. Descubrir las mentiras: observar cómo los scripts pueden ocultar errores si no se tiene cuidado.
3. Actuar como árbitro: usar exit 1 para detener el juego cuando se produce una infracción.

Este patrón de «comprobar y salir» marca la diferencia entre un script frágil y uno profesional.