Bei der Fehlerbehandlung gruppieren Sie oft eng miteinander verbundene Anweisungen. Wenn eine dieser Anweisungen während der Ausführung einen Fehler verursacht, macht es keinen Sinn, mit den restlichen Anweisungen fortzufahren. Stattdessen versuchen Sie, den Fehler so gut wie möglich zu beheben. Dies erinnert lose an Transaktionen (aber ohne Atomizität).

Sehen wir uns Code ohne Fehlerbehandlung an

function processFiles() {
    var fileNames = collectFileNames();
    var entries = extractAllEntries(fileNames);
    processEntries(entries);
}
function extractAllEntries(fileNames) {
    var allEntries = new Entries();
    fileNames.forEach(function (fileName) {
        var entry = extractOneEntry(fileName);
        allEntries.add(entry);  // (1)
    });
}
function extractOneEntry(fileName) {
    var file = openFile(fileName);  // (2)
    ...
}
...

Was ist der beste Weg, auf einen Fehler in openFile() bei (2) zu reagieren? Offensichtlich sollte die Anweisung (1) nicht mehr ausgeführt werden. Aber wir wollen extractAllEntries() auch nicht abbrechen. Stattdessen reicht es aus, die aktuelle Datei zu überspringen und mit der nächsten fortzufahren. Um dies zu tun, fügen wir der vorherigen Code Fehlerbehandlung hinzu.

function extractAllEntries(fileNames) {
    var allEntries = new Entries();
    fileNames.forEach(function (fileName) {
        try {
            var entry = extractOneEntry(fileName);
            allEntries.add(entry);
        } catch (exception) {  // (2)
            errorLog.log('Error in '+fileName, exception);
        }
    });
}
function extractOneEntry(fileName) {
    var file = openFile(fileName);
    ...
}
function openFile(fileName) {
    if (!exists(fileName)) {
        throw new Error('Could not find file '+fileName); // (1)
    }
    ...
}

Es gibt zwei Aspekte der Fehlerbehandlung

Bei (1) sind die folgenden Konstrukte aktiv

    processFile()
        extractAllEntries(...)
            fileNames.forEach(...)
                function (fileName) { ... }
                    try { ... } catch (exception) { ... }
                        extractOneEntry(...)
                            openFile(...)

Die throw-Anweisung bei (1) durchläuft diesen Baum und verlässt alle Konstrukte, bis sie auf eine aktive try-Anweisung stößt. Dann ruft sie den catch-Block dieser Anweisung auf und übergibt ihm den Ausnahmewert.

Die Fehlerbehandlung in JavaScript funktioniert wie in den meisten Programmiersprachen: Eine try-Anweisung gruppiert Anweisungen und ermöglicht es Ihnen, Ausnahmen in diesen Anweisungen abzufangen.

throw «value»;

// Don't do this
if (somethingBadHappened) {
    throw 'Something bad happened';
}

if (somethingBadHappened) {
    throw new Error('Something bad happened');
}

try {
    «try_statements»
}
⟦catch («exceptionVar») {
   «catch_statements»
}⟧
⟦finally {
   «finally_statements»
}⟧

function throwIt(exception) {
    try {
        throw exception;
    } catch (e) {
        console.log('Caught: '+e);
    }
}

> throwIt(3);
Caught: 3
> throwIt('hello');
Caught: hello
> throwIt(new Error('An error happened'));
Caught: Error: An error happened

function throwsError() {
    throw new Error('Sorry...');
}
function cleansUp() {
    try {
        throwsError();
    } finally {
        console.log('Performing clean-up');
    }
}

> cleansUp();
Performing clean-up
Error: Sorry...

function idLog(x) {
    try {
        console.log(x);
        return 'result';
    } finally {
        console.log("FINALLY");
    }
}

> idLog('arg')
arg
FINALLY
'result'

var count = 0;
function countUp() {
    try {
        return count;
    } finally {
        count++;  // (1)
    }
}

> countUp()
0
> count
1

ECMAScript standardisiert die folgenden Fehlerkonstruktoren. Die Beschreibungen sind aus der ECMAScript 5-Spezifikation zitiert:

Hier sind die Eigenschaften von Fehlern:

Die üblichen Fehlerquellen sind entweder extern (falsche Eingabe, fehlende Datei usw.) oder intern (ein Fehler im Programm). Insbesondere im letzteren Fall treten unerwartete Ausnahmen auf und Sie müssen debuggen. Oft haben Sie keinen laufenden Debugger. Für das „manuelle“ Debugging sind zwei Informationen hilfreich:

Sie können einen Teil des ersten Punkts (Daten) entweder in die Meldung oder in die Eigenschaften eines Fehlerobjekts einfügen. Der zweite Punkt (Ausführung) wird auf vielen JavaScript-Engines über Stack-Traces unterstützt, Schnappschüsse des Aufrufstapels, als die Fehlerobjekte erstellt wurden. Das folgende Beispiel gibt einen Stack-Trace aus:

function catchIt() {
    try {
        throwIt();
    } catch (e) {
        console.log(e.stack); // print stack trace
    }
}
function throwIt() {
    throw new Error('');
}

Hier ist die Interaktion

> catchIt()
Error
    at throwIt (~/examples/throwcatch.js:9:11)
    at catchIt (~/examples/throwcatch.js:3:9)
    at repl:1:5

Wenn Sie Stack-Traces wünschen, benötigen Sie die Dienste der integrierten Fehlerkonstruktoren. Sie können einen vorhandenen Konstruktor verwenden und Ihre eigenen Daten daran anhängen. Oder Sie können einen Unterkonstruktor erstellen, dessen Instanzen sich über instanceof von denen anderer Fehlerkonstruktoren unterscheiden lassen. Leider ist dies (für integrierte Konstruktoren) kompliziert; siehe Kapitel 28, um zu erfahren, wie dies geht.