Kann ich einen Fehler von async ohne Verwendung von erwarten?

Question

Können Fehler von einem nicht erwarteten Async-Aufruf abgefangen, an eine ursprüngliche Kapselung von try/catch gesendet oder eine nicht abgefangene Ausnahme ausgelöst werden?

Hier ist ein Beispiel dafür, was ich meine:

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(); 

In diesem Szenario wird die von fn2 geworfen Fehler leise geschluckt werden, und auf jeden Fall nicht von den ursprünglichen try/catch gefangen. Ich glaube, dies ist das erwartete Verhalten, da fn2 höchstwahrscheinlich in die Ereignisschleife verschoben wird, um irgendwann in der Zukunft fertig zu werden, und test ist es egal, wann es fertig ist (was beabsichtigt ist).

Gibt es eine Möglichkeit, sicherzustellen, dass Fehler nicht versehentlich von einer Struktur wie dieser verschluckt werden, anstatt try/catch intern fn2 zu setzen und so etwas wie einen Fehler zu tun? Ich würde mich sogar mit einem nicht erfaßten Fehler begnügen, ohne zu wissen, wie man ihn fängt, denke ich - ich erwarte nicht, dass geworfene Fehler ein typischer Programmfluß mit dem sind, was ich schreibe, aber das Schlucken macht das Debuggen relativ nervig.

Seitliche Notiz, ich benutze Babel, um den Code mit der Babel-Laufzeit-Transformation zu transpilieren und mit Knoten auszuführen.

Answer 1

mit unhandled Umgang abgelehnt nativen Versprechen (und Asynchron/erwarten verwendet native Versprechen) ist ein jetzt unterstützte Funktion in V8. Es wird im neuesten Chrome verwendet, um Debuginformationen auszugeben, wenn ein abgelehntes Versprechen nicht behandelt wird. versuchen Sie Folgendes an the Babel REPL:

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(); 
    } 
})() 

Sie sehen, dass, obwohl die Ausnahme von doStuff() verloren geht (weil wir nicht await verwenden, wenn wir es nennen), Chrome meldet, dass ein abgelehnter Versprechen an die Konsole nicht behandelte war :

Dies ist auch in Node.js verfügbar 4.0+, obwohl es hören erfordert a special unhandledRejection event:

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 
}); 

Answer 2

Wenn Sie mit promises vertraut sind, sie verwenden. Wenn nicht, können Sie dieses Beispiel versuchen, Ihnen mehr asynchron zu machen codieren :)

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();