¿Cómo se puede manejar un error (rechazo) de una…

Al usar await con una promesa, los errores (rechazos) pueden ser manejados de varias maneras:

Construcción try...catch: La forma más común y recomendada. Permite capturar elegantemente errores lanzados durante la resolución (resolve) o rechazo (reject) de la promesa.

async function fetchData() {
  try {
    const response = await fetch('https://api.example.com/data');
    if (!response.ok) {
      throw new Error(`¡Error HTTP! estado: ${response.status}`);
    }
    const data = await response.json();
    console.log(data);
  } catch (error) {
    console.error('Error al obtener datos:', error);
    // Manejo adicional del error o notificación al usuario
  }
}

fetchData();

Método .catch() después de await: Menos preferido, pero posible. El error será manejado en el callback .catch(), si la promesa es rechazada.

async function fetchData() {
  const response = await fetch('https://api.example.com/data')
    .catch(error => {
      console.error('Error al realizar fetch:', error);
      // Manejo del error fetch
      throw error; // Re-lanzar el error para manejo posterior si es necesario
    });

  if (response && !response.ok) {
       console.error(`¡Error HTTP! estado: ${response.status}`);
       // Manejo del error HTTP
  }

  if (response && response.ok) {
      const data = await response.json()
          .catch(error => {
              console.error('Error al parsear JSON:', error);
              // Manejo del error de parseo JSON
          });
      if (data) {
          console.log(data);
      }
  }
}

fetchData();

Este método puede volverse engorroso al manejar múltiples puntos potenciales de fallo.

Manejo con valor de retorno de error: Algunas bibliotecas o funciones propias pueden devolver una tupla [datos, error] en lugar de rechazar la promesa.

async function safelyFetchData() {
   const [data, error] = await safePromise(fetch('https://api.example.com/data'));
   if (error) {
      console.error('Error general al obtener datos:', error);
      return null; // O otro valor que indique fallo
   }
   // Se asume que safePromise también maneja errores response.ok
   console.log(data);
   return data;
}

// Ejemplo de implementación de safePromise (simplificado)
async function safePromise(promise) {
    try {
        const result = await promise;
         // Aquí puede haber una verificación result.ok para fetch
         if (result && result.ok !== undefined && !result.ok) {
             throw new Error(`¡Error HTTP! estado: ${result.status}`);
         }
        // Para fetch, quizás sea necesario await result.json()
        if (result && typeof result.json === 'function') {
            const jsonData = await result.json();
            return [jsonData, null];
        }
        return [result, null];
    } catch (error) {
        return [null, error];
    }
}

safelyFetchData();

Este patrón (a menudo llamado "error-first callback" o "manejo de errores estilo go") es útil cuando se requiere manejar errores localmente sin interrumpir la ejecución de la función.

El método más limpio y legible es usar try...catch alrededor del bloque de código que contiene await.

¿Cómo se puede manejar un error (rechazo) de una promesa al usar await?