14 oktober 2025Svenska

En omfattande guide för att förstå och implementera TypeScript-mellanprogram i Express.js-applikationer. Utforska avancerade typpmönster för robust och underhållbar kod.

TypeScript Mellanprogram: Bemästra Typpatrön för Express Mellanprogram

Express.js, ett minimalistiskt och flexibelt webapplikationsramverk för Node.js, tillåter utvecklare att bygga robusta och skalbara API:er och webbapplikationer. TypeScript förbättrar Express genom att lägga till statisk typning, förbättra kodunderhåll och fånga fel tidigt. Mellanprogramfunktioner är en hörnsten i Express, vilket gör att du kan fånga upp och bearbeta förfrågningar innan de når dina rutt-hanterare. Den här artikeln utforskar avancerade TypeScript-typpmönster för att definiera och använda Express-mellanprogram, vilket förbättrar typsäkerheten och kodtydligheten.

Förstå Express Mellanprogram

Mellanprogramfunktioner är funktioner som har åtkomst till begäranobjektet (req), svarobjektet (res) och nästa mellanprogramfunktion i applikationens begäran-svar-cykel. Mellanprogramfunktioner kan utföra följande uppgifter:

Exekvera vilken kod som helst.
Gör ändringar i begäran- och svarobjekten.
Avsluta begäran-svar-cykeln.
Anropa nästa mellanprogramfunktion i stacken.

Mellanprogramfunktioner körs sekventiellt när de läggs till i Express-applikationen. Vanliga användningsfall för mellanprogram inkluderar:

Logga begäranden.
Autentisera användare.
Auktorisera åtkomst till resurser.
Validera begärandedata.
Hantera fel.

Grundläggande TypeScript Mellanprogram

I en grundläggande TypeScript Express-applikation kan en mellanprogramfunktion se ut så här:

            
import { Request, Response, NextFunction } from 'express';

function loggerMiddleware(req: Request, res: Response, next: NextFunction) {
  console.log(`Request: ${req.method} ${req.url}`);
  next();
}

export default loggerMiddleware;

Detta enkla mellanprogram loggar begäransmetoden och URL:en till konsolen. Låt oss bryta ner typannotationerna:

Request: Representerar Express-begäranobjektet.
Response: Representerar Express-svarobjektet.
NextFunction: En funktion som, när den anropas, exekverar nästa mellanprogram i stacken.

Du kan använda detta mellanprogram i din Express-applikation så här:

            
import express from 'express';
import loggerMiddleware from './middleware/loggerMiddleware';

const app = express();
const port = 3000;

app.use(loggerMiddleware);

app.get('/', (req, res) => {
  res.send('Hello, world!');
});

app.listen(port, () => {
  console.log(`Server listening on port ${port}`);
});

Avancerade Typpatrön för Mellanprogram

Även om det grundläggande mellanprogramsexemplet är funktionellt saknar det flexibilitet och typsäkerhet för mer komplexa scenarier. Låt oss utforska avancerade typpmönster som förbättrar mellanprogramutveckling med TypeScript.

1. Anpassade Begäran/Svarstyper

Ofta behöver du utöka Request- eller Response-objekten med anpassade egenskaper. Till exempel, efter autentisering, kanske du vill lägga till en user-egenskap till Request-objektet. TypeScript låter dig förstärka befintliga typer med hjälp av deklarationssammanslagning.

            
// src/types/express/index.d.ts
import { Request as ExpressRequest } from 'express';

declare global {
  namespace Express {
    interface Request {
      user?: {
        id: string;
        email: string;
        // ... other user properties
      };
    }
  }
}

export {}; // This is needed to make the file a module

I det här exemplet förstärker vi Express.Request-gränssnittet för att inkludera en valfri user-egenskap. Nu, i ditt autentiseringsmellanprogram, kan du fylla i den här egenskapen:

            
import { Request, Response, NextFunction } from 'express';

function authenticationMiddleware(req: Request, res: Response, next: NextFunction) {
  // Simulate authentication logic
  const userId = req.headers['x-user-id'] as string; // Or fetch from a token, etc.

  if (userId) {
    // In a real application, you would fetch the user from a database
    req.user = {
      id: userId,
      email: `user${userId}@example.com`
    };
    next();
  } else {
    res.status(401).send('Unauthorized');
  }
}

export default authenticationMiddleware;

Och i dina rutt-hanterare kan du säkert komma åt req.user-egenskapen:

            
import express from 'express';
import authenticationMiddleware from './middleware/authenticationMiddleware';

const app = express();
const port = 3000;

app.use(authenticationMiddleware);

app.get('/profile', (req: Request, res: Response) => {
  if (req.user) {
    res.send(`Hello, ${req.user.email}! Your user ID is ${req.user.id}`);
  } else {
    // This should never happen if the middleware is working correctly
    res.status(500).send('Internal Server Error');
  }
});

app.listen(port, () => {
  console.log(`Server listening on port ${port}`);
});

2. Mellanprogramfabriker

Mellanprogramfabriker är funktioner som returnerar mellanprogramfunktioner. Det här mönstret är användbart när du behöver konfigurera mellanprogram med specifika alternativ eller beroenden. Tänk till exempel på ett loggningsmellanprogram som loggar meddelanden till en specifik fil:

            
import { Request, Response, NextFunction } from 'express';
import fs from 'fs';
import path from 'path';

function createLoggingMiddleware(logFilePath: string) {
  return (req: Request, res: Response, next: NextFunction) => {
    const logMessage = `[${new Date().toISOString()}] Request: ${req.method} ${req.url}\n`;
    fs.appendFile(logFilePath, logMessage, (err) => {
      if (err) {
        console.error('Error writing to log file:', err);
      }
      next();
    });
  };
}

export default createLoggingMiddleware;

Du kan använda den här mellanprogramfabriken så här:

            
import express from 'express';
import createLoggingMiddleware from './middleware/loggingMiddleware';

const app = express();
const port = 3000;

const logFilePath = path.join(__dirname, 'logs', 'requests.log');
app.use(createLoggingMiddleware(logFilePath));

app.get('/', (req, res) => {
  res.send('Hello, world!');
});

app.listen(port, () => {
  console.log(`Server listening on port ${port}`);
});

3. Asynkron Mellanprogram

Mellanprogramfunktioner behöver ofta utföra asynkrona operationer, till exempel databasfrågor eller API-anrop. För att hantera asynkrona operationer korrekt måste du se till att next-funktionen anropas efter att den asynkrona operationen har slutförts. Du kan uppnå detta med hjälp av async/await eller Promises.

            
import { Request, Response, NextFunction } from 'express';

async function asyncMiddleware(req: Request, res: Response, next: NextFunction) {
  try {
    // Simulate an asynchronous operation
    await new Promise(resolve => setTimeout(resolve, 100));
    console.log('Asynchronous operation completed');
    next();
  } catch (error) {
    next(error); // Pass the error to the error handling middleware
  }
}

export default asyncMiddleware;

Viktigt: Kom ihåg att hantera fel i ditt asynkrona mellanprogram och skicka dem till felhanteringsmellanprogrammet med next(error). Detta säkerställer att fel hanteras och loggas korrekt.

4. Felhanteringsmellanprogram

Felhanteringsmellanprogram är en speciell typ av mellanprogram som hanterar fel som uppstår under begäran-svar-cykeln. Felhanteringsmellanprogramfunktioner har fyra argument: err, req, res och next.

            
import { Request, Response, NextFunction } from 'express';

function errorHandler(err: any, req: Request, res: Response, next: NextFunction) {
  console.error(err.stack);
  res.status(500).send('Something went wrong!');
}

export default errorHandler;

Du måste registrera felhanteringsmellanprogram efter alla andra mellanprogram och rutt-hanterare. Express identifierar felhanteringsmellanprogram genom förekomsten av de fyra argumenten.

            
import express from 'express';
import asyncMiddleware from './middleware/asyncMiddleware';
import errorHandler from './middleware/errorHandler';

const app = express();
const port = 3000;

app.use(asyncMiddleware);

app.get('/', (req, res) => {
  throw new Error('Simulated error!'); // Simulate an error
});

app.use(errorHandler); // Error handling middleware MUST be registered last

app.listen(port, () => {
  console.log(`Server listening on port ${port}`);
});

5. Begäranvalideringsmellanprogram

Begäranvalidering är en avgörande aspekt av att bygga säkra och tillförlitliga API:er. Mellanprogram kan användas för att validera inkommande begärandedata och säkerställa att de uppfyller vissa kriterier innan de når dina rutt-hanterare. Bibliotek som joi eller express-validator kan användas för begäranvalidering.

Här är ett exempel med express-validator:

            
import { Request, Response, NextFunction } from 'express';
import { body, validationResult } from 'express-validator';

const validateCreateUserRequest = [
  body('email').isEmail().normalizeEmail(),
  body('password').isLength({ min: 8 }),
  (req: Request, res: Response, next: NextFunction) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({ errors: errors.array() });
    }
    next();
  }
];

export default validateCreateUserRequest;

Detta mellanprogram validerar fälten email och password i begäranorganet. Om valideringen misslyckas returneras ett 400 Bad Request-svar med en array av felmeddelanden. Du kan använda detta mellanprogram i dina rutt-hanterare så här:

            
import express from 'express';
import validateCreateUserRequest from './middleware/validateCreateUserRequest';

const app = express();
const port = 3000;

app.post('/users', validateCreateUserRequest, (req, res) => {
  // If validation passes, create the user
  res.send('User created successfully!');
});

app.listen(port, () => {
  console.log(`Server listening on port ${port}`);
});

6. Beroendeinjektion för Mellanprogram

När dina mellanprogramfunktioner beror på externa tjänster eller konfigurationer kan beroendeinjektion hjälpa till att förbättra testbarheten och underhållbarheten. Du kan använda en beroendeinjektionsbehållare som tsyringe eller helt enkelt skicka beroenden som argument till dina mellanprogramfabriker.

Här är ett exempel med en mellanprogramfabrik med beroendeinjektion:

            
// src/services/UserService.ts
export class UserService {
  async createUser(email: string, password: string): Promise {
    // In a real application, you would save the user to a database
    console.log(`Creating user with email: ${email} and password: ${password}`);
    await new Promise(resolve => setTimeout(resolve, 500)); // Simulate a database operation
  }
}

            
// src/middleware/createUserMiddleware.ts
import { Request, Response, NextFunction } from 'express';
import { UserService } from '../services/UserService';

function createCreateUserMiddleware(userService: UserService) {
  return async (req: Request, res: Response, next: NextFunction) => {
    try {
      const { email, password } = req.body;
      await userService.createUser(email, password);
      res.status(201).send('User created successfully!');
    } catch (error) {
      next(error);
    }
  };
}

export default createCreateUserMiddleware;

            
// src/app.ts
import express from 'express';
import createCreateUserMiddleware from './middleware/createUserMiddleware';
import { UserService } from './services/UserService';
import errorHandler from './middleware/errorHandler';

const app = express();
const port = 3000;

app.use(express.json()); // Parse JSON request bodies

const userService = new UserService();
const createUserMiddleware = createCreateUserMiddleware(userService);

app.post('/users', createUserMiddleware);

app.use(errorHandler);

app.listen(port, () => {
  console.log(`Server listening on port ${port}`);
});

Bästa Metoder för TypeScript Mellanprogram

Håll mellanprogramfunktioner små och fokuserade. Varje mellanprogramfunktion bör ha ett enda ansvar.
Använd beskrivande namn för dina mellanprogramfunktioner. Namnet ska tydligt ange vad mellanprogrammet gör.
Hantera fel korrekt. Fånga alltid fel och skicka dem till felhanteringsmellanprogrammet med next(error).
Använd anpassade begäran/svarstyper för att förbättra typsäkerheten. Öka Request- och Response-gränssnitten med anpassade egenskaper efter behov.
Använd mellanprogramfabriker för att konfigurera mellanprogram med specifika alternativ.
Dokumentera dina mellanprogramfunktioner. Förklara vad mellanprogrammet gör och hur det ska användas.
Testa dina mellanprogramfunktioner noggrant. Skriv enhetstester för att säkerställa att dina mellanprogramfunktioner fungerar korrekt.

Slutsats

TypeScript förbättrar avsevärt utvecklingen av Express-mellanprogram genom att lägga till statisk typning, förbättra kodunderhåll och fånga fel tidigt. Genom att bemästra avancerade typpmönster som anpassade begäran/svarstyper, mellanprogramfabriker, asynkron mellanprogram, felhanteringsmellanprogram och begäranvalideringsmellanprogram kan du bygga robusta, skalbara och typsäkra Express-applikationer. Kom ihåg att följa bästa metoder för att hålla dina mellanprogramfunktioner små, fokuserade och väldokumenterade.