TypeScript + Node.js Guide pratique
TypeScript est largement utilisé dans le développement back-end de Node.js. Ce tutoriel couvre la configuration et l'utilisation de TypeScript pour les projets Node.js.
L'utilisation de TypeScript rend le code Node.js plus sûr et plus facile à maintenir, particulièrement adapté aux projets backend de taille moyenne à grande.
Tutoriel Node.js : Voirhttps://www.example.com/nodejs/nodejs-tutorial.html
Diagramme SVG : Structure du projet Node.js + TypeScript
Pourquoi utiliser TypeScript dans Node.js
Les projets Node.js impliquent souvent une logique métier complexe et un traitement de données, et la base de code peut croître rapidement.
L'utilisation de TypeScript peut : fournir une vérification des types à la compilation pour réduire les erreurs d'exécution ; tirer parti des suggestions intelligentes de l'IDE pour améliorer l'efficacité du développement ; rendre le code plus facile à lire et à maintenir.
De nombreux grands projets Node.js (comme NestJS) recommandent ou utilisent TypeScript par défaut.
Avantages :La vérification statique des types de TypeScript peut détecter des problèmes potentiels pendant le développement, ce qui est plus efficace que le débogage à l'exécution.
Initialisation du projet
Tout d'abord, initialisez le projet Node.js et installez les dépendances liées à TypeScript.
Initialiser le projet
npm init -y
# Installer TypeScript et Node.jsDéfinitions de types
# -D signifie installer en tant que dépendance de développement
npm install -D typescript @types/node ts-node nodemon
# Initialiser tsconfig.json
npx tsc --init
Notes :
@types/nodeFournit des définitions de types pour les API Node.js,ts-nodePeut exécuter directement des fichiers TypeScript,nodemonSurveille les modifications de fichiers et redémarre automatiquement.
Configuration de tsconfig.json
Configure les options du compilateur TypeScript, optimisées pour les projets Node.js.
tsconfig.json
"compilerOptions": {
// Cible de compilation : ES2020
"target": "ES2020",
// Système de modules : CommonJS (nativement pris en charge par Node.js)
"module": "commonjs",
// Bibliothèques activées
"lib": ["ES2020"],
// Répertoire de sortie
"outDir": "./dist",
// Répertoire racine des sources
"rootDir": "./src",
// Mode strict (toujours activé)
"strict": true,
// Interopérabilité des modules ES
"esModuleInterop": true,
// Ignorer les vérifications de bibliothèque
"skipLibCheck": true,
// Imposer une casse cohérente dans les noms de fichiers
"forceConsistentCasingInFileNames": true,
// Stratégie de résolution des modules
"moduleResolution": "node",
// Générer les fichiers de déclaration
"declaration": true
},
// Fichiers à compiler
"include": ["src/**/*"],
// Fichiers exclus
"exclude": ["node_modules", "dist"]
}
Configuration recommandée :Recommandé pour les projets Node.js à utiliser
module: "commonjs", qui est le système de modules nativement pris en charge par Node.js.
Définition des types
Définissez les interfaces de type du projet dans le répertoire types.
src/types/index.ts
export interface User {
id: number; // ID utilisateur
name: string; // Nom d'utilisateur
email: string; // E-mail
createdAt: Date; // Date de création
}
// Objet de transfert de données pour la création d'un utilisateur
export interface CreateUserDTO {
name: string; // Nom d'utilisateur (requis)
email: string; // E-mail (requis)
password: string; // Mot de passe (requis)
}
// Type de réponse de l'API (générique)
export interface ApiResponse<T> {
success: boolean; // Indique si l'opération a réussi
data?: T; // Données en cas de succès
error?: string; // Message d'erreur en cas d'échec
}
Définitions de types :Centralisez les définitions de types dans le répertoire types pour faciliter la maintenance et la réutilisation.
Implémentation des services
Implémentez la logique métier dans le répertoire services, en utilisant les types définis.
src/services/userService.ts
import { User, CreateUserDTO, ApiResponse } from "../types";
// Classe de service utilisateur
class UserService {
// Liste des utilisateurs (stockage en mémoire)
private users: User[] = [];
// ID utilisateur suivant
private nextId = 1;
// Créer un utilisateur
createUser(dto: CreateUserDTO): ApiResponse<User> {
try {
// Créer un objet utilisateur
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: "Échec de la création de l'utilisateur" };
}
}
// Obtenir un seul utilisateur
getUser(id: number): ApiResponse<User> {
const user = this.users.find(u => u.id === id);
if (!user) {
return { success: false, error: "Utilisateur non trouvé" };
}
return { success: true, data: user };
}
// Obtenir tous les utilisateurs
getAllUsers(): ApiResponse<User[]> {
return { success: true, data: this.users };
}
}
// Exporter le singleton
export default new UserService();
Résultat de l'exécution :
UserService 实例化成功
Couche de service :La logique métier est centralisée dans la couche de service pour faciliter les tests et la réutilisation.
Création de routes API
Créez des API RESTful en utilisant le framework Express.
src/index.ts
import userService from "./services/userService";
// Créer l'application Express
const app = express();
// Analyser les corps de requête JSON
app.use(express.json());
// Obtenir tous les utilisateurs
app.get("/api/users", (req: Request, res: Response) => {
const result = userService.getAllUsers();
res.json(result);
});
// Obtenir un seul utilisateur
app.get("/api/users/:id", (req: Request, res: Response) => {
const id = parseInt(req.params.id);
const result = userService.getUser(id);
res.json(result);
});
// Créer un utilisateur
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(`Serveur en cours d'exécution à http://localhost:${PORT}`);
});
Résultat de l'exécution :
服务器运行在 http://localhost:3000
Indications de type :En utilisant
RequestetResponsetype, l'IDE fournira des suggestions complètes de propriétés.
package.json Scripts
Configurer les scripts npm pour simplifier le flux de travail de développement.
package.json
"scripts": {
// Compiler TypeScript
"build": "tsc",
// Exécuter le JavaScript compilé
"start": "node dist/index.js",
// Mode développement : utiliser nodemon pour surveiller les modifications et redémarrer automatiquement
"dev": "nodemon --exec ts-node src/index.ts",
// Exécuter les tests
"test": "jest"
}
}
Efficacité de développement :L'utilisation
npm run devpermet le redémarrage automatique du serveur après modification du code.
Notes
- Mode strict :Toujours activer strict: true
- Sélection du module :Les projets Node.js doivent utiliser commonjs
- Définitions de types :Installez @types/node pour obtenir les types d'API
- Outils de développement :Utilisez ts-node pour le rechargement à chaud
Bonnes pratiques :Gardez les définitions de types séparées de la logique métier pour faciliter les tests et la maintenance.
Résumé
TypeScript est un excellent choix pour le développement backend avec Node.js.
- Configuration du projet :Utilisez tsconfig.json pour configurer les options de compilation
- Définitions de types :Gérez les interfaces de manière centralisée dans le répertoire types
- Couche service :Séparer la logique métier des routes
- Routes :Utiliser Express pour créer des API RESTful
- Outils de développement :ts-node et nodemon améliorent l'efficacité du développement
Autres extensionsRecommandation :Utilisez TypeScript directement pour les nouveaux projets ; les projets existants peuvent être migrés progressivement.