JavaScript
Foutafhandeling

Syntaxis

• probeer {…} catch (error) {…}
• probeer {…} eindelijk {…}
• probeer {…} catch (error) {…} eindelijk {…}
• gooi nieuwe fout ([bericht]);
• throw Error ([bericht]);

Opmerkingen

Interactie met beloften

Promise.resolve(5)
    .then(result => {
        throw new Error("I don't like five");
    })
    .then(result => {
        console.info("Promise resolved: " + result);
    })
    .catch(error => {
        console.error("Promise rejected: " + error);
    });

Promise rejected: Error: I don't like five

async function main() {
  try {
    await Promise.reject(new Error("Invalid something"));
  } catch (error) {
    console.log("Caught error: " + error);
  }
}
main();

Caught error: Invalid something

Fout objecten

Runtime-fouten in JavaScript zijn exemplaren van het object Error . Het object Error kan ook worden gebruikt zoals het is of als basis voor door de gebruiker gedefinieerde uitzonderingen. Het is mogelijk om elk type waarde te gooien, bijvoorbeeld tekenreeksen, maar u wordt sterk aangemoedigd om Error of een van de afgeleide producten te gebruiken om ervoor te zorgen dat foutopsporingsinformatie - zoals stacktraces - correct wordt bewaard.

De eerste parameter voor de constructor Error is het voor mensen leesbare foutbericht. Probeer altijd een nuttig foutbericht op te geven van wat er is misgegaan, ook als u elders aanvullende informatie kunt vinden.

try {
   throw new Error('Useful message');
} catch (error) {
   console.log('Something went wrong! ' + error.message);
}

Volgorde van bewerkingen plus geavanceerde gedachten

Zonder een try-catch-blok zullen ongedefinieerde functies fouten veroorzaken en de uitvoering stoppen:

undefinedFunction("This will not get executed");
console.log("I will never run because of the uncaught error!");

Zal een fout veroorzaken en de tweede regel niet uitvoeren:

// Uncaught ReferenceError: undefinedFunction is not defined

Je hebt een try-catch-blok nodig, vergelijkbaar met andere talen, om ervoor te zorgen dat je die fout opvangt, zodat code kan blijven uitvoeren:

try {
    undefinedFunction("This will not get executed");
} catch(error) {
    console.log("An error occured!", error);
} finally {
    console.log("The code-block has finished");
}
console.log("I will run because we caught the error!");

Nu hebben we de fout ontdekt en kunnen we er zeker van zijn dat onze code wordt uitgevoerd

// An error occured! ReferenceError: undefinedFunction is not defined(…)
// The code-block has finished
// I will run because we caught the error!

Wat als er een fout optreedt in ons vangblok !?

try {
    undefinedFunction("This will not get executed");
} catch(error) {
    otherUndefinedFunction("Uh oh... ");
    console.log("An error occured!", error);
} finally {
    console.log("The code-block has finished");
}
console.log("I won't run because of the uncaught error in the catch block!");

We zullen de rest van ons catch-blok niet verwerken, en de uitvoering zal stoppen behalve het laatste block.

// The code-block has finished
// Uncaught ReferenceError: otherUndefinedFunction is not defined(…)

Je kunt altijd je blokken proberen te nestelen, maar dat zou je niet moeten doen, want dat wordt extreem rommelig ..

try {
    undefinedFunction("This will not get executed");
} catch(error) {
    try {
        otherUndefinedFunction("Uh oh... ");
    } catch(error2) {
        console.log("Too much nesting is bad for my heart and soul...");
    }
    console.log("An error occured!", error);
} finally {
    console.log("The code-block has finished");
}
console.log("I will run because we caught the error!");

Zal alle fouten van het vorige voorbeeld opvangen en het volgende loggen:

//Too much nesting is bad for my heart and soul...
//An error occured! ReferenceError: undefinedFunction is not defined(…)
//The code-block has finished
//I will run because we caught the error!

Dus, hoe kunnen we alle fouten opvangen? Voor niet-gedefinieerde variabelen en functies: dat kan niet.

Je moet ook niet elke variabele en functie in een try / catch-blok wikkelen, omdat dit eenvoudige voorbeelden zijn die slechts één keer voorkomen totdat je ze oplost. Voor objecten, functies en andere variabelen waarvan u weet dat ze bestaan, maar u weet niet of hun eigenschappen of subprocessen of bijwerkingen zullen bestaan, of u in sommige omstandigheden enkele foutstaten verwacht, moet u uw foutafhandeling abstraheren op een bepaalde manier. Hier is een heel eenvoudig voorbeeld en implementatie.

Zonder een beschermde manier om niet-vertrouwde of uitzonderingsworpmethoden aan te roepen:

function foo(a, b, c) {
    console.log(a, b, c);
    throw new Error("custom error!");
}
try {
    foo(1, 2, 3);
} catch(e) { 
    try {
        foo(4, 5, 6); 
    } catch(e2) {
        console.log("We had to nest because there's currently no other way...");
    }
    console.log(e);
}
// 1 2 3
// 4 5 6
// We had to nest because there's currently no other way...
// Error: custom error!(…)

En met bescherming:

function foo(a, b, c) {
    console.log(a, b, c);
    throw new Error("custom error!");
}
function protectedFunction(fn, ...args) {
    try {
        fn.apply(this, args);
    } catch (e) {
        console.log("caught error: " + e.name + " -> " + e.message);
    }
}

protectedFunction(foo, 1, 2, 3);
protectedFunction(foo, 4, 5, 6);

// 1 2 3
// caught error: Error -> custom error!
// 4 5 6
// caught error: Error -> custom error!

We vangen fouten op en verwerken nog steeds alle verwachte code, hoewel met een enigszins andere syntaxis. Hoe dan ook zal werken, maar naarmate u geavanceerdere applicaties bouwt, wilt u misschien nadenken over manieren om uw foutafhandeling samen te vatten.

Fouttypen

Er zijn zes specifieke kernfoutconstructeurs in JavaScript:

• EvalError - maakt een instantie die een fout vertegenwoordigt die optreedt met betrekking tot de algemene functie eval() .

• InternalError - maakt een instantie die een fout weergeeft die optreedt wanneer een interne fout in de JavaScript-engine wordt gegenereerd. Bijvoorbeeld "te veel recursie". (Alleen ondersteund door Mozilla Firefox )

• RangeError - maakt een instantie die een fout weergeeft die optreedt wanneer een numerieke variabele of parameter buiten het geldige bereik valt.

• ReferenceError - maakt een instantie die een fout weergeeft die optreedt bij het dereferen van een ongeldige verwijzing.

• SyntaxError - maakt een instantie die een syntaxisfout vertegenwoordigt die optreedt tijdens het parseren van code in eval() .

• TypeError - maakt een instantie die een fout weergeeft die optreedt wanneer een variabele of parameter geen geldig type is.

• URIError - maakt een instantie die een fout weergeeft die optreedt wanneer aan encodeURI() of decodeURI() ongeldige parameters worden doorgegeven.

Als u een foutafhandelingsmechanisme implementeert, kunt u controleren welk soort fout u van code oploopt.

try {
    throw new TypeError();
}
catch (e){
    if(e instanceof Error){
        console.log('instance of general Error constructor');
    }

    if(e instanceof TypeError) {
        console.log('type error');
    }
}

In dat geval is e een instantie van TypeError . Alle fouttypen breiden de basisconstructor Error , daarom is het ook een instantie van Error .

Als we dat in gedachten houden, zien we dat het in de meeste gevallen zinloos is om e als een instantie van Error .