javascript - pagina - script async defer

¿Puedo detectar un error de async sin usar esperar?

Question

¿Se pueden detectar los errores de una llamada asíncrona no esperada, enviarlos a una prueba / captura encapsulante original, o generar una excepción no detectada?

Aquí hay un ejemplo de lo que quiero decir:

async function fn1() {
console.log(''executing fn1'');
}
async function fn2() {
console.log(''executing fn2'');
throw new Error(''from fn2'');
}
async function test() {
try {
await fn1();
fn2();
}
catch(e) {
console.log(''caught error inside test:'', e);
}
}
test();

En este escenario, el error lanzado desde fn2 se tragará en silencio, y definitivamente no será detectado por el try/catch original. Creo que este es el comportamiento esperado, ya que es muy probable que fn2 esté siendo empujado fuera del ciclo de eventos para finalizar en algún momento en el futuro, y a la test no le importa cuándo termina (lo cual es intencional).

¿Hay alguna forma de garantizar que los errores no se traguen accidentalmente con una estructura como esta, sin poner un try/catch interno en fn2 y hacer algo como emitir un error? Incluso me conformaría con un error no detectado sin saber cómo atraparlo, creo. No creo que los errores de lanzamiento sean un flujo típico del programa con lo que estoy escribiendo, pero los errores de tragar hacen que sea relativamente molesto depurar.

Nota al margen, estoy usando Babel para transpilar el código usando la transformación babel-runtime, y ejecutarlo con el nodo.

Answer 1

Si estás familiarizado con las promises , úsalos. Si no, puedes probar este ejemplo para hacer que tu código sea más asíncrono :)

function fn1(callback) {
console.log(''executing fn1'');
callback({status: true});
}
function fn2(callback) {
console.log(''executing fn2'');
callback({status: false});
}
function test() {
fn1(function(result) {
console.log(''fn1 executed with status '' + result.status);
});
fn2(function(result) {
console.log(''fn2 executed with status '' + result.status);
if (result.status == false) {
console.log(''error in fn2'');
}
});
}
test();

Answer 2

Tratar con promesas nativas rechazadas no manejadas (y async / await usa promesas nativas) es una característica compatible ahora en V8. Se usa en el Chrome más reciente para generar información de depuración cuando una promesa rechazada no se maneja; Prueba lo siguiente en el REPL de Babel :

async function executor() {
console.log("execute");
}
async function doStuff() {
console.log("do stuff");
throw new Error("omg");
}
function handleException() {
console.error("Exception handled");
}
(async function() {
try {
await executor();
doStuff();
} catch(e) {
handleException();
}
})()

Verá que, aunque se pierde la excepción de doStuff() (porque no estamos usando await cuando lo llamamos), Chrome registra que una promesa rechazada no se manejó en la consola:

Esto también está disponible en Node.js 4.0+, aunque requiere escuchar un evento especial unhandledRejection :

process.on(''unhandledRejection'', function(reason, p) {
console.log("Unhandled Rejection at: Promise ", p, " reason: ", reason);
// application specific logging, throwing an error, or other logic here
});