Bootcamp i backendudvikling med Node.js · Lektion

Strategier til global fejlhåndtering

Implementer en centraliseret mekanisme til fejlhåndtering, der håndterer undtagelser på en kontrolleret måde og giver ensartede fejlresponses.

Lektion 2 af 411 trin

Strategier til global fejlhåndtering er en gratis Bootcamp i backendudvikling med Node.js-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Bootcamp i backendudvikling med Node.js, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Bootcamp i backendudvikling med Node.js-kurset indeholder 4 lektioner i alt.

Centraliserede fejl i Express

Når du opbygger en API, er fejl uundgåelige. Den måde, du håndterer dem på, kan have stor betydning for brugeroplevelsen og applikationens stabilitet.

Spredte try...catch-blokke i hver rute kan blive rodede og inkonsekvente. Denne lektion introducerer global fejlhåndtering i Express.js.

Express' standardsvar ved fejl

Som standard vil Express, hvis der opstår en fejl i en Express-rute eller middleware, og fejlen ikke fanges:

sende et svar med statuskoden 500 Internal Server Error.
inkludere fejlens stack trace i svaret.

Denne standardadfærd er ikke ideel i produktion, fordi den afslører følsomme serveroplysninger for klienter.

Den særlige fejl-middleware

Express genkender en særlig type middleware til fejlhåndtering. I modsætning til almindelig middleware, som tager (req, res, next), tager fejlmiddleware fire argumenter:

err: Fejlobjektet, som Express sender videre.
req: Anmodningsobjektet.
res: Svarobjektet.
next: Den næste middleware-funktion.

Express ved, at al anden middleware skal springes over, og sender fejlen direkte til denne særlige handler.

Din første fejl-middleware

Lad os oprette en grundlæggende middleware-funktion til fejlhåndtering. Denne middleware-funktion skal placeres efter alle andre ruter og middleware-funktioner i din app.js-fil.

Prøv at køre denne enkle Express-applikation:

const express = require('express');
const app = express();

// A route that intentionally throws an error
app.get('/error', (req, res, next) => {
  const err = new Error('Something went wrong!');
  err.statusCode = 400;
  next(err); // Pass the error to the error middleware
});

// Global Error Handling Middleware (must be last)
app.use((err, req, res, next) => {
  console.error(err.stack); // Log the error for debugging
  const statusCode = err.statusCode || 500;
  res.status(statusCode).json({
    status: 'error',
    message: err.message || 'An unexpected error occurred!'
  });
});

const PORT = 3000;
app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
  console.log('Visit http://localhost:3000/error to see error handling');
});

Driftsfejl kontra programmeringsfejl

Det er afgørende at skelne mellem fejltyper:

Driftsfejl: Forudsigelige fejl fra systemhandlinger, f.eks. ugyldige brugerinput, netværksproblemer eller manglende ressourcer. Det er »bløde« fejl, som vi kan håndtere på en ordentlig måde og sende specifikke meddelelser til klienten.
Programmeringsfejl: Fejl i din kode, f.eks. forsøg på at læse en egenskab fra undefined eller fejl ved databaseforbindelsen. Det er »hårde« fejl, som angiver et problem med applikationens logik og måske kræver, at processen genstartes.

Vores globale handler bør behandle disse forskelligt.

Oprettelse af brugerdefinerede fejl

For bedre at kunne kategorisere og håndtere fejl kan vi oprette brugerdefinerede fejlklistre. Det giver os mulighed for at føje bestemte egenskaber som statusCode og isOperational til vores fejl.

Her er en enkel AppError-klasse:

// utils/appError.js
class AppError extends Error {
  constructor(message, statusCode) {
    super(message);

    this.statusCode = statusCode;
    this.status = `${statusCode}`.startsWith('4') ? 'fail' : 'error';
    this.isOperational = true;

    Error.captureStackTrace(this, this.constructor);
  }
}

module.exports = AppError;

Brug af brugerdefinerede fejl i ruter

Nu hvor vi har vores AppError-klasse, kan vi bruge den i vores ruter til at udløse specifikke driftsfejl. Når en AppError udløses og fanges af next(err), kan vores globale handler give et tilpasset svar.

Kør dette eksempel, og prøv at besøge /user/123 (gyldigt) og /user/abc (ugyldigt ID):

const express = require('express');
const AppError = require('./utils/appError'); // Assuming appError.js is in a 'utils' folder
const app = express();

// Example route using custom error
app.get('/user/:id', (req, res, next) => {
  const userId = parseInt(req.params.id);

  if (isNaN(userId)) {
    return next(new AppError('Invalid user ID provided!', 400));
  }

  res.status(200).json({
    status: 'success',
    data: { id: userId, name: `User ${userId}` }
  });
});

// Global Error Handling Middleware (must be last)
app.use((err, req, res, next) => {
  console.error(err.stack);

  const statusCode = err.statusCode || 500;
  const status = err.status || 'error';

  if (err.isOperational) {
    res.status(statusCode).json({
      status: status,
      message: err.message
    });
  } else {
    // For programmatic errors, send a generic message in production
    res.status(500).json({
      status: 'error',
      message: 'Something went very wrong!'
    });
  }
});

const PORT = 3000;
app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
  console.log('Visit http://localhost:3000/user/1 to see success');
  console.log('Visit http://localhost:3000/user/abc to see custom error');
});

// --- Create utils/appError.js with the content from the previous scene for this to run ---

Intelligente fejlmeddelelser

Vores fejlhandler kan forbedres yderligere, så den giver forskellige svar afhængigt af miljøet (udvikling kontra produktion).

Udvikling: Send alle fejloplysninger (stack trace) med til fejlfinding.
Produktion: Send korte, brugervenlige meddelelser ved driftsfejl og generiske meddelelser ved programmeringsfejl for at skjule interne oplysninger.

Denne tilgang holder din API sikker og informativ.

Håndtering af det uforudsete

Express-middleware fanger kun fejl, der opstår i anmodnings-svar-cyklussen og sendes videre med next(err). Hvad med fejl uden for denne cyklus?

Ikke-fangede undtagelser: Synkrone fejl, som ikke håndteres af en try...catch-blok.
Ubehandlede afvisninger: Promise-afvisninger, der ikke har en .catch()-handler.

Node.js stiller globale lyttere til proceshændelser til rådighed for disse kritiske fejl. De bør ideelt set lukke applikationen ned, efter at fejlen er logget.

// In your server.js or app.js, before app.listen
process.on('uncaughtException', err => {
  console.error('UNCAUGHT EXCEPTION! Shutting down...');
  console.error(err.name, err.message, err.stack);
  process.exit(1); // Exit with failure code
});

// After app.listen, for unhandled promise rejections
process.on('unhandledRejection', err => {
  console.error('UNHANDLED REJECTION! Shutting down...');
  console.error(err.name, err.message);
  // Optionally close server first, then exit
  server.close(() => {
    process.exit(1);
  });
});

Udfordring: Fejlhåndtering

Du har lært om fejlhåndtering i Express. Hvilken af følgende er den korrekte signatur for en Express-middleware til fejlhåndtering?

Besvar den i den interaktive lektion

Opsummering af global fejlhåndtering

Flot arbejde! Du har lært at implementere robust fejlhåndtering i dine Express-applikationer.

Express bruger en særlig middleware med fire argumenter til fejlhåndtering.
Skeln mellem driftsfejl og programmeringsfejl.
Opret brugerdefinerede fejlklsser for at føje kontekst til dine fejl.
Implementer globale lyttere til ikke-fangede undtagelser og ubehandlede afvisninger.

Centraliseret fejlhåndtering gør din API mere pålidelig, sikker og nemmere at fejlfinde!

Gratis at komme i gang

Lær JavaScript med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 22
Lektioner: 92

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Strategier til global fejlhåndtering” gratis?

Ja — hele teksten til “Strategier til global fejlhåndtering” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Bootcamp i backendudvikling med Node.js-kurset, skal du opgradere til CoddyKit PRO. Bootcamp i backendudvikling med Node.js-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Strategier til global fejlhåndtering”?

Implementer en centraliseret mekanisme til fejlhåndtering, der håndterer undtagelser på en kontrolleret måde og giver ensartede fejlresponses. Du øver dig i Bootcamp i backendudvikling med Node.js med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Bootcamp i backendudvikling med Node.js?

Der kræves ingen tidligere erfaring. Bootcamp i backendudvikling med Node.js på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.

Hvor lang tid tager lektionen “Strategier til global fejlhåndtering”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Bootcamp i backendudvikling med Node.js-lektion?

Ja. Alle Bootcamp i backendudvikling med Node.js-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Udvikling af brugerdefineret Express-middleware
Strategier til global fejlhåndtering
Inputvalidering med Joi/Express-Validator
Authentication-middleware med JWT

← Tilbage til Bootcamp i backendudvikling med Node.js