Tutorial JavaScript: Excepciones

Las excepciones en JavaScript son eventos que ocurren durante la ejecución de un programa cuando se encuentra con un error o una situación inesperada. Estas excepciones pueden ser manejadas utilizando bloques de código específicos, como try, catch y finally. El manejo de excepciones permite anticiparse a posibles problemas y manejarlos de manera adecuada, en lugar de permitir que el programa falle o se comporte de manera inesperada.

La estructura try-catch-finally

try

El bloque try es donde se coloca el código que puede arrojar una excepción. Este bloque es seguido por uno o más bloques catch que definen cómo manejar las diferentes excepciones que pueden ocurrir en el bloque try.

try {
  // Código que podría generar una excepción
} catch (error) {
  // Código para manejar la excepción
}

catch

El bloque catch es utilizado para capturar y manejar las excepciones que son arrojadas dentro del bloque try. Se puede tener múltiples bloques catch para manejar distintos tipos de errores o excepciones, aunque esto no es muy común en JavaScript.

try {
  // Código que podría generar una excepción
} catch (error) {
  if (error instanceof TypeError) {
    // Manejar error de tipo TypeError
  } else if (error instanceof ReferenceError) {
    // Manejar error de tipo ReferenceError
  } else {
    // Manejar todos los otros tipos de error
  }
}

finally

El bloque finally es opcional y se coloca al final de la secuencia try-catch. Este bloque contiene código que se ejecutará independientemente de si ocurrió una excepción o no, y siempre se ejecuta después de los bloques try y catch.

try {
  // Código que podría generar una excepción
} catch (error) {
  // Código para manejar la excepción
} finally {
  // Código que se ejecutará siempre, haya o no haya ocurrido una excepción
}

Ejemplo de uso de excepciones en JavaScript

A continuación, se muestra un ejemplo de cómo usar excepciones en JavaScript para manejar errores en una función que realiza la división entre dos números:

function dividir(a, b) {
  try {
    // Lanzar excepción si 'a' o 'b' no son de tipo number
    if (typeof a !== 'number' || typeof b !== 'number') {
      throw new TypeError('Los argumentos deben ser números');
    }

    // Lanzar excepción si se intenta dividir por 0
    if (b === 0) {
      throw new Error('La división por cero no está permitida');
    }
    
    return a / b;
  } catch (error) {
    console.error('Error al realizar la división:', error);
  } finally {
    console.log('La función dividir() ha sido ejecutada');
  }
}

const resultado1 = dividir(10, 2); // 5
const resultado2 = dividir(10, 'a'); // Error al realizar la división: Los argumentos deben ser números
const resultado3 = dividir(10, 0); // Error al realizar la división: La división por cero no está permitida

En el ejemplo anterior, la función dividir() utiliza un bloque try para intentar realizar la división entre dos números. Si los argumentos provistos no son números, se arroja una excepción de tipo TypeError. Si el divisor (b) es igual a cero, se arroja una excepción de tipo Error con un mensaje específico. Estas excepciones son manejadas en el bloque catch, donde se muestra un mensaje de error en la consola. El bloque finally se utiliza para mostrar un mensaje indicando que la función ha sido ejecutada, independientemente de si ocurrió una excepción o no.