TypeScript + Node.js Praxishandbuch

TypeScript wird in der Node.js-Backend-Entwicklung weit verbreitet eingesetzt. Dieses Tutorial behandelt die TypeScript-Konfiguration und -Verwendung für Node.js-Projekte.

Die Verwendung von TypeScript macht Node.js-Code sicherer und einfacher zu warten, besonders geeignet für mittlere bis große Backend-Projekte.

Node.js-Tutorial: Ansehenhttps://www.example.com/nodejs/nodejs-tutorial.html

SVG-Diagramm: Node.js + TypeScript-Projektstruktur

Warum TypeScript in Node.js verwenden

Node.js-Projekte umfassen oft komplexe Geschäftslogik und Datenverarbeitung, und die Codebasis kann schnell wachsen.

Die Verwendung von TypeScript kann: Typüberprüfung zur Kompilierungszeit bieten, um Laufzeitfehler zu reduzieren; intelligente IDE-Vorschläge nutzen, um die Entwicklungseffizienz zu verbessern; den Code leichter lesbar und wartbar machen.

Viele große Node.js-Projekte (wie NestJS) empfehlen TypeScript oder verwenden es standardmäßig.

Vorteile:Die statische Typprüfung von TypeScript kann potenzielle Probleme während der Entwicklung erkennen, was effizienter ist als das Debuggen zur Laufzeit.

Projektinitialisierung

Zuerst das Node.js-Projekt initialisieren und TypeScript-bezogene Abhängigkeiten installieren.

Projekt initialisieren

# npm initialisieren
npm init -y

# TypeScript und Node installieren.jsTypdefinitionen
# -D bedeutet Installation als Entwicklungsabhängigkeit
npm install -D typescript @types/node ts-node nodemon

# Initialisiere tsconfig.json
npx tsc --init

Notizen:@types/nodeStellt Typdefinitionen für Node.js-APIs bereit,ts-nodeKann TypeScript-Dateien direkt ausführen,nodemonÜberwacht Dateiänderungen und startet automatisch neu.

tsconfig.json-Konfiguration

Konfiguriert TypeScript-Compiler-Optionen, optimiert für Node.js-Projekte.

tsconfig.json

{
"compilerOptions": {
// Kompilierungsziel: ES2020
"target": "ES2020",

// Modulsystem: CommonJS (nativ von Node.js unterstützt)
"module": "commonjs",

// Aktivierte Bibliotheken
"lib": ["ES2020"],

// Ausgabeverzeichnis
"outDir": "./dist",

// Quellstammverzeichnis
"rootDir": "./src",

// Strict-Modus (immer aktiviert)
"strict": true,

// ES-Modul-Interoperabilität
"esModuleInterop": true,

// Bibliotheksprüfungen überspringen
"skipLibCheck": true,

// Konsistente Groß-/Kleinschreibung in Dateinamen erzwingen
"forceConsistentCasingInFileNames": true,

// Strategie zur Modulauflösung
"moduleResolution": "node",

// Deklarationsdateien generieren
"declaration": true
},
// Zu kompilierende Dateien
"include": ["src/**/*"],
// Ausgeschlossene Dateien
"exclude": ["node_modules", "dist"]
}

Empfohlene Konfiguration:Empfohlen für die Verwendung in Node.js-Projektenmodule: "commonjs", das das von Node.js nativ unterstützte Modulsystem ist.

Typen definieren

Definieren Sie die Typ-Schnittstellen des Projekts im Verzeichnis types.

src/types/index.ts

// Benutzertypdefinition
export interface User {
id: number; // Benutzer-ID
name: string; // Benutzername
email: string; // E-Mail
createdAt: Date; // Erstellungszeit
}

// Datenübertragungsobjekt zum Erstellen eines Benutzers
export interface CreateUserDTO {
name: string; // Benutzername (erforderlich)
email: string; // E-Mail (erforderlich)
password: string; // Passwort (erforderlich)
}

// API-Antworttyp (generisch)
export interface ApiResponse<T> {
success: boolean; // Ob erfolgreich
data?: T; // Daten bei Erfolg
error?: string; // Fehlermeldung bei Fehler
}

Typdefinitionen:Zentralisieren Sie Typdefinitionen im types-Verzeichnis für einfachere Wartung und Wiederverwendung.

Dienste implementieren

Implementieren Sie Geschäftslogik im services-Verzeichnis unter Verwendung der definierten Typen.

src/services/userService.ts

// Typdefinitionen importieren
import { User, CreateUserDTO, ApiResponse } from "../types";

// Benutzer-Serviceklasse
class UserService {
// Benutzerliste (In-Memory-Speicher)
private users: User[] = [];
// Nächste Benutzer-ID
private nextId = 1;

// Benutzer erstellen
createUser(dto: CreateUserDTO): ApiResponse<User> {
try {
// Benutzerobjekt erstellen
const user: User = {
id: this.nextId++,
name: dto.name,
email: dto.email,
createdAt: new Date()
};
this.users.push(user);
return { success: true, data: user };
} catch (error) {
return { success: false, error: "Benutzer konnte nicht erstellt werden" };
}
}

// Einen einzelnen Benutzer abrufen
getUser(id: number): ApiResponse<User> {
const user = this.users.find(u => u.id === id);
if (!user) {
return { success: false, error: "Benutzer nicht gefunden" };
}
return { success: true, data: user };
}

// Alle Benutzer abrufen
getAllUsers(): ApiResponse<User[]> {
return { success: true, data: this.users };
}
}

// Singleton exportieren
export default new UserService();

Ausführungsergebnis:

UserService 实例化成功

Service-Schicht:Die Geschäftslogik ist in der Service-Schicht zentralisiert, um Tests und Wiederverwendung zu erleichtern.

API-Routen erstellen

RESTful-APIs mit dem Express-Framework erstellen.

src/index.ts

import express, { Request, Response } from "express";
import userService from "./services/userService";

// Express-App erstellen
const app = express();
// JSON-Anfrage-Bodies parsen
app.use(express.json());

// Alle Benutzer abrufen
app.get("/api/users", (req: Request, res: Response) => {
const result = userService.getAllUsers();
res.json(result);
});

// Einen einzelnen Benutzer abrufen
app.get("/api/users/:id", (req: Request, res: Response) => {
const id = parseInt(req.params.id);
const result = userService.getUser(id);
res.json(result);
});

// Benutzer erstellen
app.post("/api/users", (req: Request, res: Response) => {
const result = userService.createUser(req.body);
res.json(result);
});

const PORT = 3000;
app.listen(PORT, () => {
console.log(`Server läuft unter http://localhost:${PORT}`);
});

Ausführungsergebnis:

服务器运行在 http://localhost:3000

Typ-Hinweise:Bei Verwendung vonRequestundResponsetype bietet die IDE vollständige Eigenschaftsvorschläge.

package.json-Skripte

Konfigurieren Sie npm-Skripte, um den Entwicklungsworkflow zu vereinfachen.

package.json

{
"scripts": {
// TypeScript kompilieren
"build": "tsc",

// Kompiliertes JavaScript ausführen
"start": "node dist/index.js",

// Entwicklungsmodus: nodemon verwenden, um Änderungen zu beobachten und automatisch neu zu starten
"dev": "nodemon --exec ts-node src/index.ts",

// Tests ausführen
"test": "jest"
}
}

Entwicklungseffizienz:Verwendennpm run devermöglicht automatischen Serverneustart nach Codeänderungen.

Hinweise

Strict-Modus:Immer strict: true aktivieren
Modulauswahl:Node.js-Projekte sollten commonjs verwenden
Typdefinitionen:Installieren Sie @types/node, um API-Typen zu erhalten
Entwicklungswerkzeuge:Verwenden Sie ts-node für Hot Reloading

Bewährte Methoden:Halten Sie Typdefinitionen getrennt von der Geschäftslogik, um Tests und Wartung zu erleichtern.

Zusammenfassung

TypeScript ist eine ausgezeichnete Wahl für die Backend-Entwicklung mit Node.js.

Projektkonfiguration:Verwenden Sie tsconfig.json, um Kompilierungsoptionen zu konfigurieren
Typdefinitionen:Verwalten Sie Schnittstellen zentral im types-Verzeichnis
Service-Schicht:Geschäftslogik von Routen trennen
Routen:Express zum Erstellen von RESTful APIs verwenden
Entwicklungstools:ts-node und nodemon verbessern die Entwicklungseffizienz

Empfehlung:TypeScript direkt für neue Projekte verwenden; bestehende Projekte können schrittweise migriert werden.

Andere Erweiterungen

Typsystem-Grundlagen

Fortgeschritten