Error handling

Voor het bouwen van een app is het handig om te weten of je functies goed uitgevoerd worden. Met de error handling kan je fouten op een goede manier afhandelen door, error object, try/ catch, throw of promises toe te passen in je code.

Er zijn verschillende manieren om fouten generen in node.js:

• throw the error (er wordt hierdoor een uitzondering gemaakt)
• error callback (fouten worden meegegeven in de “callback” functie, waar vervolgens de resultaten asynchrone worden bijgewerkt)
• promise function (een fout doorgeven aan “promise” belofte )
• een error event op een “EventEmitter” zetten.

Voorbeeld: In dit voorbeeld wordt een “error” meegegeven in een callback functie. Dit wordt vaak gebruikt in node.js, omdat de meeste fouten asynchroon zijn. Het is namelijk zeer ongebruikelijk om fouten van een synchrone functie te moeten opvangen.

callback(new Error('something bad happened'));

try catch finally voorbeeld code 2:

try {
  // code that we will 'try' to run
} catch(error) {
  // code to run if there are any problems
} finally {
  // run this code no matter what the previous outcomes
}

Operational errors

Operational errors zijn fouten die tijdens runtime kunnen voorkomen. Dit hoeft niet te beteken dat er een bug in het programma zit. Echter kunnen problemen ontstaan in het systeem zelf, bijvoorbeeld bij onvoldoende geheugen, systeemconfiguratie (wanneer route niet goed gekoppeld zijn), netwerk (server op afstand). Voorbeelden:

• kon geen verbinding maken met de server
• kon de hostnaam niet vinden
• ongeldige gebruikersinvoer
• verzoek time-out
• server heeft een 500-reactie geretourneerd

Programmeur errors

Dit zijn problemen die voorkomen in het programma. Bij het aanpassen van je code kan dit vermeden worden.

• probeerde de eigenschap 'ongedefinieerd' te lezen
• een asynchrone functie genoemd zonder terugbellen
• doorgegeven een "string" waar een object werd verwacht
• heeft een object doorgegeven waar een IP-adresreeks werd verwacht

Error handling types

throw levert synschroon een fout op

• Van beide kanten (bijvoorbeeld, de beller of de beller van de beller)
• als er van beide kanten geen try/ catch is gebruikt, crasht het programma meestal.
• Door het toepassen van try/ catch, kan er fouten opgevangen worden.

Callbacks

• Het meest eenvoudige manier om een fout asynchroon af te handelen.
• De callback functie kan je toepassen wanner de asynchrone bewerking is voltooid.

Promise afwijzingen

• fouten asynchroon afhandelen
• populair sinds Node.js versie 8, biedt ondersteuning async/ await
• Door async/ await, kan asynchrone code worden geschreven die lijken op synchrone. Fouten kan opgevangen worden door try/ catch.

Synchroon

• code die van boven naar beneden worden uitgevoerd.
• hierbij wacht de browser totdat javascript is geladen en uitgevoerd.
• het uitvoeren van javascript wordt uitgesteld -> Asynchroon

Asynchroon

• Er is een grote kans dat je code tijdens runtime crasht
• Callbacks zijn goede oplossingen
• innestelen van callbacks heet callback hell (niet meer overzichtelijk)
• promise lost callbacks hell op.
• async-functies laten ons onze code op een synchrone manier schrijven
• laad sneller de pagina, doordat er meerdere taken uitgevoerd kan worden
• try/ catch wordt vaak gebruikt

Error handling function aanmaken

Als eerst zet je een mappen structuur op, door een mapje "handlingError" met daarin een error.js bestand.

Error.js file Hierin worden constructies functies aangemaakt waarin je de error melding wil meegeven aan de gebruiker.

// error constructor wordt aangemaakt 
class ErrorHandler extends Error {
    constructor(statusCode, message) {
      super();
      this.statusCode = statusCode;
      this.message = message;
    }
  }

  //functie waarin een error wordt meegenomen
  // gebruiker krijg dit te zien
  const handleError = (err, res) => {
    const { statusCode, message } = err;
    res.status(statusCode).json({
      status: "error, sorry its not working",
      statusCode,
      message
    });
  };

  //module bijwerken
  module.exports = {
    ErrorHandler,
    handleError
  };

  //bron: https://dev.to/nedsoft/central-error-handling-in-express-3aej

Error handling aanroepen In de server.js ga je de functie aanroepen en definiëren.

// Het aanroepen van de error mapje, verwijst naar de pad
const {  handleError, ErrorHandler } = require('./handlingError/error');

// error handling testen
app.get('/error', (req, res) => {
  throw new ErrorHandler(500, 'Internal server error');
});

app.use((err, req, res, next) => {
  handleError(err, res);
});

localhost:3000/error uitkomst

Bronnen

Marketingtracer (2021). Javascript uitstellen. Geraadpleegd van, https://www.marketingtracer.com/nl/seo/verbeter-website-snelheid-defer-javascript

Joyent (2021). Error Handling in Node.js. Geraadpleegd van, https://www.joyent.com/node-js/production/design/errors