Salir de promesas sin el try/catch

Hace unas horas estaba leyendo este post donde una persona explica como poder cambiar de cadenas de promesas a un mundo síncrono con async/await. Sin emgargo, el problema con async/await es la necesidad de usar try/catch para poder tener un fallback de cuando una promesa truena.
Efectivamente cambias esto:

const myFn = () => {
  myPromise
    .then(response => {
      console.log('here')
    })
    .catch(error => {
      console.log('error here')
    })
}

a

const myFn = async () => {
  let response
  try {
    response = await myPromise
  } catch (error) {
    response = error
  }
}

Básicamente no hay mejora, pues el código sigue siendo igual de complicado de leer, además si no manejas el catch de la promesa rota, el intérprete te va a regresar una excepción.

Entonces en el post, @avishkardalvi nos explica una forma de poder escapar del async/await hell concentrando varias respuestas de estas promesas en un solo lugar y posteriormente regresando una tupla [error, respuesta].
Siento que es una buena forma de darle la vuelta a este problema, pero le faltó un poquito para que fuera redonda.
Entonces ESTE es mi approach para el mismo problema, basado en la propuesta original.

const aP = async promise => {
  let res, err
  try {
    res = await promise
  } catch (e) {
    err = e
  }
  return [err, res]
}

const algo = async _ => {
  const p = new Promise(resolve => resolve('success'))
  const s = await aP(p)
  const p2 = new Promise((_, reject) => reject('error'))
  const s2 = await aP(p2)
  console.log(s, s2)
}

algo()

Esto nos va a contestar en cada respuesta de aP una tupla con el formato [error, response] y eliminando todas las necesidades de tener que meter try/catch en cada una de las promesas y al mismo tiempo conservando la legibilidad del código resultante.

Esto se compone de dos partes:

Parte 1

El helper

const aP = async promise => {
  let res, err
  try {
    res = await promise
  } catch (e) {
    err = e
  }
  return [err, res]
}

aP (corto para async promise) es una función que recibe una promesa tal cual, define los dos posibles resultados, intenta ejecutar la promesa y aqui está el único try/catch necesario, observemos que aP es una función async, es decir que incluso la función misma regresa una promesa que se pude encolar con otras promesas.

Parte 2

La implementación

const algo = async _ => {
  const p = new Promise(resolve => resolve('success'))
  const s = await aP(p)
  const p2 = new Promise((_, reject) => reject('error'))
  const s2 = await aP(p2)
  console.log(s, s2)
}

algo()

Aquí simplemente definimos una función async donde tenermos dos ejemplos de promesas p y p2, donde p contesta con un resolve (ejemplo todo cool) y p2 contesta con un reject (ejemplo de una promesa rota)
Ambas promesas las pasamos por el aP quien intenta resolverlas y regresarnos una respuesta. El resultado es el siguiente:

Promise { <pending> }
[ undefined, 'success' ] [ 'error', undefined ]

Como pueden ver, en ambos casos, la tupla se genera corréctamente y no hay ningún warning acerca de que hubo un reject sin catch que rompiera la promesa.

¿Qué piensan de esta solución? ¿Les sería útil?

Coméntame en el telegram 😀

Recuerda si algo de lo que escribo te sirve, no dudes en compartirlo, o éntrale al patreon si deseas ayudarme con un cafecin para seguir escribiendo este tipo de babosadas 😀

Zero out