TypeScript + Node.js Práctica

TypeScript se usa ampliamente en el desarrollo backend de Node.js. Este tutorial presenta la configuración y el uso de TypeScript en proyectos Node.js.

Usar TypeScript hace que el código Node.js sea más seguro y fácil de mantener, especialmente adecuado para proyectos backend de mediana y gran escala.

Ver tutorial de Node.js:https://www.example.com/nodejs/nodejs-tutorial.html

Diagrama SVG: Estructura del proyecto Node.js + TypeScript

¿Por qué usar TypeScript en Node.js?

Los proyectos Node.js suelen involucrar lógica de negocio compleja y procesamiento de datos, y el número de líneas de código crece rápidamente.

Usar TypeScript permite: proporcionar verificación de tipos en tiempo de compilación, reduciendo errores en tiempo de ejecución; aprovechar los avisos inteligentes del IDE, mejorando la eficiencia del desarrollo; y hacer que el código sea más legible y fácil de mantener.

Muchos proyectos grandes de Node.js (como NestJS) recomiendan o usan TypeScript por defecto.

Ventajas:La verificación estática de tipos de TypeScript puede detectar problemas potenciales durante el desarrollo, lo que es más eficiente que depurar en tiempo de ejecución.

Inicialización del proyecto

Primero, inicialice el proyecto Node.js e instale las dependencias relacionadas con TypeScript.

Inicializar el proyecto

# Inicializar npm
npm init -y

# Instalar TypeScript y Node.jsDefinición de tipos
# -D indica instalar como dependencia de desarrollo
npm install -D typescript @types/node ts-node nodemon

# Inicializar tsconfig.json
npx tsc --init

Explicación:@types/nodeProporciona las definiciones de tipos para la API de Node.js,ts-nodePuede ejecutar directamente archivos TypeScript,nodemonEscucha los cambios de archivos y se reinicia automáticamente.

Configuración de tsconfig.json

Configure las opciones del compilador de TypeScript, optimizadas para proyectos Node.js.

tsconfig.json

{
"compilerOptions": {
// Objetivo de compilación: ES2020
"target": "ES2020",

// Sistema de módulos: CommonJS (compatible nativamente con Node.js)
"module": "commonjs",

// Bibliotecas habilitadas
"lib": ["ES2020"],

// Directorio de salida
"outDir": "./dist",

// Directorio raíz del código fuente
"rootDir": "./src",

// Modo estricto (siempre activado)
"strict": true,

// Interoperabilidad de módulos ES
"esModuleInterop": true,

// Omitir verificación de bibliotecas
"skipLibCheck": true,

// Forzar consistencia de mayúsculas/minúsculas en nombres de archivo
"forceConsistentCasingInFileNames": true,

// Estrategia de resolución de módulos
"moduleResolution": "node",

// Generar archivos de declaración
"declaration": true
},
// Archivos a compilar
"include": ["src/**/*"],
// Archivos excluidos
"exclude": ["node_modules", "dist"]
}

Configuración recomendada:Para proyectos Node.js se recomienda usarmodule: "commonjs", que es el sistema de módulos compatible nativamente con Node.js.

Definición de tipos

Defina las interfaces de tipos del proyecto en el directorio types.

src/types/index.ts

// Definición del tipo Usuario
export interface User {
id: number; // ID del usuario
name: string; // Nombre de usuario
email: string; // Correo electrónico
createdAt: Date; // Fecha de creación
}

// Objeto de transferencia de datos para crear usuario
export interface CreateUserDTO {
name: string; // Nombre de usuario (obligatorio)
email: string; // Correo electrónico (obligatorio)
password: string; // Contraseña (obligatoria)
}

// Tipo de respuesta API (genérico)
export interface ApiResponse<T> {
success: boolean; // Si fue exitoso
data?: T; // Datos en caso de éxito
error?: string; // Mensaje de error en caso de fallo
}

Definición de tipos:Coloque las definiciones de tipos de forma centralizada en el directorio types para facilitar el mantenimiento y la reutilización.

Implementación del servicio

Implemente la lógica de negocio en el directorio services, utilizando los tipos definidos.

src/services/userService.ts

// Importar definiciones de tipos
import { User, CreateUserDTO, ApiResponse } from "../types";

// Clase de servicio de usuario
class UserService {
// Lista de usuarios (almacenamiento en memoria)
private users: User[] = [];
// Siguiente ID de usuario
private nextId = 1;

// Crear usuario
createUser(dto: CreateUserDTO): ApiResponse<User> {
try {
// Crear objeto de usuario
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: "Error al crear el usuario" };
}
}

// Obtener un usuario
getUser(id: number): ApiResponse<User> {
const user = this.users.find(u => u.id === id);
if (!user) {
return { success: false, error: "El usuario no existe" };
}
return { success: true, data: user };
}

// Obtener todos los usuarios
getAllUsers(): ApiResponse<User[]> {
return { success: true, data: this.users };
}
}

// Exportar instancia única (singleton)
export default new UserService();

Resultado de ejecución:

UserService 实例化成功

Capa de servicios:La lógica de negocio se centraliza en la capa de servicios, facilitando las pruebas y la reutilización.

Crear rutas de API

Cree una API RESTful utilizando el framework Express.

src/index.ts

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

// Crear aplicación Express
const app = express();
// Analizar el cuerpo de solicitudes JSON
app.use(express.json());

// Obtener todos los usuarios
app.get("/api/users", (req: Request, res: Response) => {
const result = userService.getAllUsers();
res.json(result);
});

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

// Crear usuario
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(`El servidor se ejecuta en http://localhost:${PORT}`);
});

Resultado de ejecución:

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

Sugerencias de tipos:UsandoRequestyResponsetipo, el IDE proporcionará sugerencias completas de propiedades.

Scripts de package.json

Configure los scripts de npm para simplificar el flujo de desarrollo.

package.json

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

// Ejecutar el JavaScript compilado
"start": "node dist/index.js",

// Modo desarrollo: usar nodemon para escuchar cambios y reiniciar automáticamente
"dev": "nodemon --exec ts-node src/index.ts",

// Ejecutar pruebas
"test": "jest"
}
}

Eficiencia de desarrollo:Usandonpm run devse puede lograr el reinicio automático del servidor después de modificar el código.

Notas importantes

Modo estricto:Siempre habilite strict: true
Selección de módulos:Los proyectos Node.js usan commonjs
Definiciones de tipos:Instale @types/node para obtener los tipos de la API
Herramientas de desarrollo:Use ts-node para implementar recarga en caliente

Mejores prácticas:Mantenga las definiciones de tipos separadas de la lógica de negocio para facilitar las pruebas y el mantenimiento.

Resumen

TypeScript es una excelente opción para el desarrollo backend de Node.js.

Configuración del proyecto:Use tsconfig.json para configurar las opciones de compilación
Definiciones de tipos:Administre las interfaces de forma centralizada en el directorio types
Capa de servicios:Separe la lógica de negocio de las rutas
Rutas:Use Express para crear una API RESTful
Herramientas de desarrollo:ts-node y nodemon mejoran la eficiencia del desarrollo

Recomendación:Los proyectos nuevos deberían usar TypeScript directamente; los proyectos antiguos pueden migrarse gradualmente.

Otras extensiones

Fundamentos del sistema de tipos

Avanzado