# Middleware Express.js – Guide till begärandekontroll 2026

*Robert Roos*
*9 augusti 2026*

> Lär dig vad middleware Express.js är och hur du bygger egna middleware-funktioner för autentisering, loggning och felhantering i dina Node.js-applikationer.

## Vad är middleware Express.js?

Middleware Express.js är funktioner som körs mellan mottagandet av en HTTP-förfrågan och skickandet av ett svar. De är hjärtat i Express.js och gör det möjligt att kontrollera begärandena innan de når dina routes. Middleware kan modifiera begärandeobjektet, svaret, eller helt enkelt logga information — möjligheterna är nästan obegränsade.

## Hur fungerar middleware i Express.js?

Middleware-funktioner i Express.js följer ett enkelt mönster: de tar emot tre parametrar — `req` (begäran), `res` (svar) och `next` (nästa middleware). När middleware är klar anropar den `next()` för att skicka kontrollen vidare i kedjan. Om middleware inte anropar `next()`, stannar begäran där.

```javascript
app.use((req, res, next) => {
  console.log('En begäran mottogs');
  next();
});
```

Denna enkla middleware loggar varje begäran och skickar sedan vidare den till nästa middleware eller route.

### Steg 1: Förstå middleware-ordningen

Middleware-ordningen i Express är kritisk. Express kör middleware i den ordning du definierar den. Om du definierar en autentiseringsmiddleware före dina routes, kontrolleras alla begäran. Om du definierar den efter, kommer den aldrig att köras för dessa routes.

```javascript
app.use(autentisering); // Körs för alla routes
app.get('/offentlig', (req, res) => res.send('Hej'));
app.use(loggning); // Körs bara för routes definierade efter denna rad
```

Detta är en av de vanligaste misstagen — att glömma att middleware-ordningen i Express påverkar vilka routes som skyddas.

### Steg 2: Skapa en enkel loggnings-middleware

En loggnings-middleware är perfekt för att börja. Den registrerar varje begäran utan att påverka applikationens logik:

```javascript
const loggningMiddleware = (req, res, next) => {
  const tid = new Date().toISOString();
  console.log(`${tid} - ${req.method} ${req.path}`);
  next();
};

app.use(loggningMiddleware);
```

Nu loggas varje begäran med tidsstämpel, HTTP-metod och sökväg. Detta är en grundläggande men kraftfull middleware.

### Steg 3: Implementera autentiserings-middleware

Autentisering är en av de viktigaste användningsområdena för custom middleware Node.js. Här är ett exempel som kontrollerar en token:

```javascript
const autentiseringMiddleware = (req, res, next) => {
  const token = req.headers.authorization;
  
  if (!token) {
    return res.status(401).json({ fel: 'Token saknas' });
  }
  
  if (token === 'Bearer hemlig-token') {
    req.anvandare = { id: 1, namn: 'Test' };
    next();
  } else {
    res.status(403).json({ fel: 'Ogiltig token' });
  }
};

app.use(autentiseringMiddleware);
app.get('/skyddad', (req, res) => {
  res.json({ meddelande: `Hej ${req.anvandare.namn}` });
});
```

Denna middleware kontrollerar att en giltig token finns i begärandehuvudena innan den tillåter åtkomst.

### Steg 4: Felhantering med middleware

Felhantering är en särskild typ av middleware Express.js med fyra parametrar: `err`, `req`, `res` och `next`. Express känner igen denna signatur och använder den för att hantera fel:

```javascript
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({ 
    fel: 'Något gick fel',
    meddelande: err.message 
  });
});
```

Felhanteringsmiddleware måste definieras sist, efter alla andra middleware och routes.

### Steg 5: Kombinera middleware för komplexa scenarier

I verkliga applikationer kombinerar du ofta flera middleware-funktioner. Du kan skicka en array av middleware till en route:

```javascript
const valideraInput = (req, res, next) => {
  if (!req.body.namn) {
    return res.status(400).json({ fel: 'Namn krävs' });
  }
  next();
};

app.post('/anvandare', 
  autentiseringMiddleware,
  valideraInput,
  (req, res) => {
    res.json({ meddelande: 'Användare skapad' });
  }
);
```

Här körs autentisering först, sedan validering, och slutligen route-handleren.

### Steg 6: Använd tredjepartsMiddleware

Express-ekosystemet erbjuder många färdiga middleware-paket. `express.json()` är en klassiker:

```javascript
app.use(express.json()); // Parsar JSON-begäran
app.use(express.static('public')); // Serverar statiska filer
```

Dessa är inbyggda middleware-funktioner som löser vanliga problem utan att du behöver skriva egen kod.

### Steg 7: Testa och debugga din middleware

När du bygger custom middleware Node.js är det viktigt att testa dem ordentligt. Använd `console.log()` för att spåra flödet:

```javascript
const debugMiddleware = (req, res, next) => {
  console.log('Middleware startad');
  console.log('Begärandemetod:', req.method);
  console.log('Sökväg:', req.path);
  next();
  console.log('Middleware slutförd');
};
```

Det sista `console.log()` körs efter att route-handleren är klar, vilket visar middleware-kedjan i aktion.

## Vanliga misstag att undvika

**Glömma `next()`**: Om du inte anropar `next()` stannar begäran. Klienten får aldrig något svar.

**Fel middleware-ordning**: Middleware måste definieras före de routes den ska påverka.

**Async-problem**: Om din middleware är asynkron, hantera fel korrekt:

```javascript
app.use(async (req, res, next) => {
  try {
    // Asynkron kod
    next();
  } catch (err) {
    next(err); // Skicka fel till felhanteringsmiddleware
  }
});
```

## Vad säger folk på Reddit och Flashback om middleware Express.js?

I webbutvecklings-forum diskuteras middleware Express.js ofta, särskilt när utvecklare stöter på problem med ordningen eller felhantering. En återkommande fråga är varför begäran inte når sin destination — svaret är nästan alltid att `next()` inte anropas eller att middleware är definierad i fel ordning. Många delar tips om att använda middleware-arrays för att hålla koden organiserad, och det finns en stark konsensus om att felhanteringsmiddleware måste komma sist. Nybörjare varnas ofta om att inte blanda asynkron logik utan korrekt error-handling, och många rekommenderar att testa middleware isolerat innan de integreras i en större applikation.

## Sammanfattning

Middleware Express.js är en kraftfull mekanism för att kontrollera HTTP-begäran i dina Node.js-applikationer. Genom att förstå middleware-ordningen och hur `next()` fungerar kan du bygga robusta autentiserings-, loggnings- och felhanteringssystem. Börja med enkla middleware-funktioner, testa dem noggrant, och bygg upp mot mer komplexa scenarier.

## Vanliga frågor

### Kan jag använda middleware på enskilda routes?

Ja, du kan skicka middleware direkt till en route: `app.get('/väg', middleware, handler)`. Du kan även skicka en array: `app.get('/väg', [middleware1, middleware2], handler)`.

### Vad är skillnaden mellan `app.use()` och `app.get()`?

`app.use()` registrerar middleware för alla HTTP-metoder och alla sökvägar (eller en specifik sökväg). `app.get()` är en route-handler för GET-begäran. Middleware-ordningen spelar roll för båda.

### Hur debuggar jag middleware-problem?

Använd `console.log()` för att spåra flödet, eller använd en debugger som `node --inspect`. Kontrollera alltid att `next()` anropas och att middleware är definierad i rätt ordning.