Tiếp tục với series, ở bài trước các bạn đã thấy code NestJS có khá nhiều cú pháp lạ với người chỉ biết JavaScript: private readonly, @Controller(), kiểu dữ liệu sau dấu :... Bài này mình sẽ giới thiệu với mọi người những phần TypeScript cần biết trước khi học NestJS.
Mình chỉ chọn những gì NestJS dùng hằng ngày, đủ để đọc hiểu code ở các bài sau.
1. TypeScript là gì? Chuẩn bị môi trường.
TypeScript là JavaScript có thêm kiểu dữ liệu. Code TypeScript được biên dịch (compile) thành JavaScript rồi mới chạy.
Kiểu dữ liệu chỉ tồn tại lúc compile: compiler tsc kiểm tra lỗi rồi xoá hết kiểu đi. Điều này rất quan trọng với NestJS.
Để chạy thử các ví dụ, các bạn tạo thư mục mới và cài TypeScript 6 (bản mà nest new đang dùng):
mkdir ts-nest && cd ts-nest
npm init -y
npm pkg set type=module
npm i -D typescript@6 @types/node@24
npm i reflect-metadata
Rồi tạo file cấu hình với các option lấy từ project do nest new tạo ra:
- tsconfig.json
{
"compilerOptions": {
"module": "nodenext",
"moduleResolution": "nodenext",
"target": "ES2023",
"strict": true,
"experimentalDecorators": true,
"emitDecoratorMetadata": true,
"rootDir": "./src",
"outDir": "./dist",
"types": ["node"]
},
"include": ["src"]
}
VD: Tạo file src/hello.ts, compile rồi chạy file JavaScript sinh ra trong dist.
const site: string = 'toidicode.com';
console.log(`Xin chào ${site}`);
npx tsc
node dist/hello.js
# Xin chào toidicode.com
Lưu ý: Node.js 24 chạy được trực tiếp node src/hello.ts bằng cách bỏ phần kiểu đi (type stripping), nhưng không hỗ trợ decorator và parameter property (phần 3). NestJS dùng cả hai nên luôn compile bằng tsc.
2. Kiểu dữ liệu, interface và type.
Kiểu được khai báo bằng dấu : sau tên biến, tham số hoặc sau dấu ngoặc của hàm (kiểu trả về). Không khai báo thì TypeScript tự suy ra: let total = 0 là number, gán total = 'mười' sẽ báo lỗi.
interface mô tả "hình dạng" của object, còn type đặt tên cho một kiểu bất kỳ, hay gặp nhất là union (một trong các giá trị).
VD: Mô tả task của TaskFlow API.
- src/types.ts
type TaskStatus = 'todo' | 'doing' | 'done';
interface Task {
id: number;
title: string;
status: TaskStatus;
dueDate?: Date; // dấu ? : không bắt buộc
}
const tasks: Task[] = [
{ id: 1, title: 'Cài đặt NestJS', status: 'done' },
{ id: 2, title: 'Viết controller', status: 'todo' },
];
function countByStatus(status: TaskStatus): number {
return tasks.filter((task) => task.status === status).length;
}
console.log(countByStatus('todo')); // 1
Nếu gọi countByStatus('closed'), tsc báo lỗi ngay chứ không đợi đến lúc chạy: Argument of type '"closed"' is not assignable to parameter of type 'TaskStatus'.
interface và type bị xoá khi compile nên lúc chạy NestJS không "nhìn thấy" chúng. Vì vậy DTO trong NestJS được viết bằng class chứ không phải interface (Bài 7).
3. Class và access modifier.
Controller, service, module trong NestJS đều là class, và TypeScript thêm cho class các access modifier:
public(mặc định): dùng được ở mọi nơi.private: chỉ dùng được bên trong class đó.protected: dùng được trong class đó và các class kế thừa.readonly: chỉ gán được một lần, khi khai báo hoặc trong constructor.
VD: Phiên bản không có decorator của controller và service ở bài trước.
- src/classes.ts
class ProjectsService {
private readonly projects: string[] = ['TaskFlow'];
findAll(): string[] {
return this.projects;
}
}
class ProjectsController {
constructor(private readonly projectsService: ProjectsService) {}
findAll(): string[] {
return this.projectsService.findAll();
}
}
const controller = new ProjectsController(new ProjectsService());
console.log(controller.findAll()); // [ 'TaskFlow' ]
Dòng constructor(private readonly projectsService: ProjectsService) {} là cách viết tắt (parameter property): vừa khai báo property projectsService, vừa gán tham số vào this.projectsService. Các bạn sẽ gặp nó trong hầu hết controller và service.
Vì có private, gọi controller.projectsService từ bên ngoài sẽ bị tsc báo lỗi. Ở đây mình tự new ProjectsService(), trong NestJS việc này do DI làm (Bài 6).
Ngoài ra class có thể implements một interface để cam kết có đủ các method của interface đó, VD pipe implements PipeTransform (Bài 9), guard implements CanActivate (Bài 12).
4. Generic.
Generic là kiểu có tham số, viết trong dấu <>, VD Array<Task> (giống Task[]) hay Promise<T>: kiểu trả về của mọi hàm async.
VD: Một kho dữ liệu trong bộ nhớ dùng được cho mọi kiểu có id.
- src/generics.ts
interface Project {
id: number;
name: string;
}
class InMemoryRepository<T extends { id: number }> {
private items: T[] = [];
add(item: T): T {
this.items.push(item);
return item;
}
findById(id: number): T | undefined {
return this.items.find((item) => item.id === id);
}
async findAll(): Promise<T[]> {
return this.items;
}
}
const projects = new InMemoryRepository<Project>();
projects.add({ id: 1, name: 'TaskFlow' });
console.log(projects.findById(1)); // { id: 1, name: 'TaskFlow' }
console.log(projects.findById(2)); // undefined
console.log(await projects.findAll()); // [ { id: 1, name: 'TaskFlow' } ]
Trong đó:
Tlà tham số kiểu,extends { id: number }bắt buộc kiểu truyền vào phải cóid.new InMemoryRepository<Project>()thayTbằngProject, nênprojects.add({ id: 2, title: 'Sai' })sẽ bị lỗi vìProjectkhông cótitle.
5. Decorator.
Decorator là một hàm được gắn vào class, method, property hoặc tham số bằng ký tự
@, dùng để thêm thông tin (metadata) hoặc thay đổi hành vi của thứ nó gắn vào.
NestJS xoay quanh decorator: @Controller(), @Get(), @Injectable()... và dùng kiểu decorator của TypeScript bật bằng experimentalDecorators ở phần 1.
VD: Tự viết hai decorator đơn giản để xem chúng hoạt động thế nào.
- src/decorators.ts
import 'reflect-metadata';
// Decorator factory tự viết (không phải của NestJS): nhận path, trả về decorator
function Controller(path: string): ClassDecorator {
return (target) => {
Reflect.defineMetadata('path', path, target);
};
}
// Decorator không làm gì, chỉ để TypeScript ghi lại metadata cho class
function Injectable(): ClassDecorator {
return () => {};
}
@Injectable()
class ProjectsService {}
@Controller('projects')
class ProjectsController {
constructor(private readonly projectsService: ProjectsService) {}
}
console.log(Reflect.getMetadata('path', ProjectsController)); // projects
console.log(Reflect.getMetadata('design:paramtypes', ProjectsController)); // [ [class ProjectsService] ]
Trong đó:
Controller('projects')là decorator factory: hàm nhận tham số và trả về decorator. Decorator nhận class (target) và lưu path vào metadata của class nhờreflect-metadata.- Option
emitDecoratorMetadatalàmtsctự ghi kiểu các tham số constructor của class có decorator vào keydesign:paramtypes.
NestJS làm đúng như vậy: @Controller('api/v1/projects') lưu path để dựng route, còn nhờ design:paramtypes mà NestJS biết ProjectsController cần một ProjectsService để tự tạo và truyền vào. Vì thế kiểu của tham số được inject phải là class, không phải interface hay type. Custom decorator của NestJS mình sẽ giới thiệu ở Bài 12.
6. Module ESM: import và export.
Như đã nói ở Bài 1, project NestJS 12 mặc định là ESM: mỗi file là một module, muốn dùng ở file khác thì export ra và import vào.
VD: Tách kiểu và hàm tạo task ra một file riêng.
- src/tasks/task.ts
export type TaskStatus = 'todo' | 'doing' | 'done';
export interface Task {
id: number;
title: string;
status: TaskStatus;
}
export function createTask(id: number, title: string): Task {
return { id, title, status: 'todo' };
}
- src/main.ts
import { createTask, type Task } from './tasks/task.js';
const task: Task = createTask(1, 'Học TypeScript');
console.log(task); // { id: 1, title: 'Học TypeScript', status: 'todo' }
Chạy npx tsc và node dist/main.js. Một số điểm cần nhớ:
- Import file trong project phải có đuôi
.jsdù file gốc là.ts, vì Node.js chạy file.jstrongdist. Thiếu đuôi,tscsẽ báo lỗi. - Import package thì không cần đuôi:
import { Controller } from '@nestjs/common'; type Taskđánh dấu import chỉ dùng làm kiểu, bị xoá khi compile. Đừng import kiểu này với class cần inject.
Muốn tìm hiểu sâu hơn, các bạn đọc thêm TypeScript Handbook.
7. Lời kết.
Như vậy mình đã điểm qua những phần TypeScript cần biết trước khi học NestJS: kiểu dữ liệu, interface và type, class với access modifier, generic, decorator và module ESM. Bài sau chúng ta sẽ cài đặt NestJS và tạo project TaskFlow API đầu tiên.
Đăng ký nhận tin.
Chúng tôi chỉ gửi tối đa 2 lần trên 1 tháng. Tuyên bố không spam mail!





0 Comments