Wie man in Promise ungefangene Ausnahmen fängt

Gibt es eine Möglichkeit, alle Ausnahmen einschließlich Promise-Ausnahmen global abzufangen? Beispiel:

    window.onerror = function myErrorHandler(errorMsg, url, lineNumber) {
        alert("Error occured: " + errorMsg);//or any message
        return false;
    }

    var myClass = function(){

    }


    var pr = new Promise(function(resolve, react){
        var myInstance = new myClass();
        myInstance.undefinedFunction(); // this will throw Exception
        resolve(myInstance);
    });


    pr.then(function(result){
        console.log(result);
    });

    // i know right will be this:
    // pr.then(function(result){
    //     console.log(result);
    // }).catch(function(e){
    //     console.log(e);
    // });

Dieses Skript stirbt stillschweigend ohne Fehler. Nichts in Feuerwanze.

Meine Frage ist, ob ich einen Fehler mache und vergessen habe, ihn zu fangen. Gibt es eine Möglichkeit, ihn global zu fangen?

Update, native Versprechen machen jetzt in den meisten Browsern Folgendes:

window.addEventListener("unhandledrejection", function(promiseRejectionEvent) { 
    // handle error here, for example log   
});

Wir haben das neulich gerade besprochen.

So würden Sie das mit Bluebird machen:

window.onpossiblyunhandledexception = function(){
    window.onerror.apply(this, arguments); // call
}

window.onerror = function(err){
    console.log(err); // logs all errors
}

Mit Bluebird ist es auch möglich zu verwenden Promise.onPossiblyUnhandledRejection. Die Aufrufe für donewerden nicht benötigt, da die Bibliothek im Gegensatz zu Q selbst nicht behandelte Ablehnungen erkennt (UPDATE 2016 - Ich habe jetzt Code für Q geschrieben und dies geschieht).

Native Versprechen - sie werden irgendwann entweder an window.onerror oder an einen neuen Handler gemeldet, aber der Spezifikationsprozess ist noch nicht abgeschlossen - können Sie hier verfolgen .

Die meisten Versprechen-Implementierungen bieten derzeit nicht die Art von Funktionalität, auf die Sie sich beziehen, aber eine Reihe von Versprechen-Bibliotheken von Drittanbietern (einschließlich Q und Bluebird ) bieten eine done()Methode, mit der nicht erfasste Fehler abgefangen und erneut ausgegeben und somit an die Konsole ausgegeben werden .

( Bearbeiten: siehe Benjamin Gruenbaums Antwort zu Bluebirds Funktionen für den Umgang mit nicht erfassten Ausnahmen)

Wenn Sie das haben, müssen Sie nur die Faustregel befolgen, dass jedes Versprechen, das Sie verwenden, entweder zurückgegeben oder beendet werden sollte mit .done():

pr.then(function(result){
    console.log(result);
})
.done();

Um aus der Q API-Referenz zu zitieren:

Die goldene Regel done gegen den then Gebrauch lautet: Entweder return Ihr Versprechen an jemand anderen, oder wenn die Kette mit Ihnen endet, rufen Sie an, um sie done zu beenden. Das Beenden mit catch reicht nicht aus, da der catchHandler selbst einen Fehler auslösen kann.

Mir ist klar, dass dies immer noch ein wenig zusätzliche Arbeit erfordert und Sie dies immer noch vergessen können, aber es ist eine Verbesserung gegenüber der Notwendigkeit, .catch()jeden Fehler explizit zu behandeln, insbesondere aus dem oben genannten Grund.

In Node.js können Sie Folgendes verwenden:

process.on('unhandledRejection', (reason, promise) => {
  console.error(`Uncaught error in`, promise);
});

Wenn Sie Code schreiben, der sowohl in einem Browser als auch in einer Node.js-Umgebung ausgeführt werden kann, können Sie Ihren Code in eine selbstausführende Funktion wie die folgende einschließen:

var isNode = (typeof process !== 'undefined' && typeof process.on !== 'undefined');
(function(on, unhandledRejection) {
    // PUT ANY CODE HERE
    on(unhandledRejection, function(error, promise) {
        console.error(`Uncaught error in`, promise);
    });
    // PUT ANY CODE HERE
})(
    isNode ? process.on.bind(process) : window.addEventListener.bind(window),
    isNode ? "unhandledRejection" : "unhandledrejection"
);

Was würde passieren, wenn Sie diesen Code verwenden:

• Wenn Sie es in einer Node.js-Umgebung ausführen würden, würde Ihr Handler an das Prozessobjekt angehängt und ausgeführt, wenn Sie eine nicht erfasste Ausnahme in einem Versprechen haben.

• Wenn Sie es in einer Browserumgebung ausführen würden, würde Ihr Handler an das Fensterobjekt angehängt und ausgeführt, wenn Sie eine nicht erfasste Ausnahme in einem Versprechen haben und Ihr Browser das unhandledrejectionEreignis unterstützt .

• Wenn Sie es in einer Browserumgebung ohne Unterstützung für ausführen unhandledrejection, können Sie Ihre nicht erfasste Ausnahme nicht abfangen, und Ihr unhandledrejectionEreignishandler wird niemals ausgelöst. Sie erhalten jedoch keine Fehler, wenn keine nicht erfassten Ausnahmen vorliegen.

Wenn Sie native Promise verwenden, ist dies ziemlich einfach.
Sie müssen nur .catcheinige wo ablehnen.

ajax(request).catch(function(rejected){
      console.log(rejected);
});

Wenn ich es nicht irgendwo fange, wird sich das nicht gefangene Versprechen immer wieder zeigen. Aber wenn ich es irgendwo fange ...