TypeScript nâng cao: thiết kế kiểu cho codebase lớn
Từ strict mode tới generics, discriminated union, mapped/conditional types và validate runtime bằng Zod — để kiểu dữ liệu chạy xuyên suốt từ database tới UI.
Gần như mọi job fullstack Node/React lương cao năm 2026 ghi "strong TypeScript". Khác biệt giữa junior
và senior không phải biết interface, mà là dùng hệ thống kiểu để làm cho trạng thái sai
không thể biểu diễn được: một API response không thể vừa loading vừa có error,
một hàm không thể nhận userId thay cho orderId. TypeScript tốt biến cả một loại bug
runtime thành lỗi biên dịch, và cho phép bạn refactor codebase 100k dòng mà không sợ.
🎯 Mục tiêu học tập
- Cấu hình tsconfig strict cho Node và React, hiểu từng cờ quan trọng
- Dùng narrowing, type guard, discriminated union và exhaustive check
- Viết generic có ràng buộc; đọc hiểu được type của thư viện
- Dùng utility, mapped, conditional và template literal types đúng chỗ
- Validate dữ liệu runtime bằng Zod và suy ra type từ schema
tsconfig strict: những cờ phải bật
{
"compilerOptions": {
"target": "ES2023",
"module": "NodeNext", // backend Node; frontend bundler dùng "ESNext" + "moduleResolution": "Bundler"
"moduleResolution": "NodeNext",
"strict": true, // bật cả nhóm strictNullChecks, noImplicitAny, ...
"noUncheckedIndexedAccess": true, // arr[0] có kiểu T | undefined — bắt rất nhiều bug
"exactOptionalPropertyTypes": true,
"noImplicitOverride": true,
"verbatimModuleSyntax": true, // bắt buộc viết `import type` cho import chỉ dùng kiểu
"skipLibCheck": true,
"outDir": "dist"
}
}
Node 22.18+/24 chạy được file .ts trực tiếp bằng type stripping (chỉ xóa kiểu,
không kiểm tra). Kiểm tra kiểu vẫn là việc của tsc --noEmit trong CI. Trong dự án thật, dùng
tsx để chạy dev và tsc/tsup để build.
Narrowing và discriminated union
type RemoteData<T, E = Error> =
| { status: 'idle' }
| { status: 'loading' }
| { status: 'success'; data: T }
| { status: 'error'; error: E };
function render(state: RemoteData<User[]>) {
switch (state.status) {
case 'idle': return 'Chưa tải';
case 'loading': return 'Đang tải…';
case 'success': return state.data.length + ' người dùng'; // TS biết có data
case 'error': return state.error.message;
default: {
const _never: never = state; // thêm status mới mà quên xử lý → lỗi biên dịch
return _never;
}
}
}
// Type guard tự viết
function isApiError(e: unknown): e is { code: string; message: string } {
return typeof e === 'object' && e !== null && 'code' in e && 'message' in e;
}
Nhiều cờ boolean
(isLoading, isError, data?) = có trạng thái vô lý. Một trường
status + union = chỉ trạng thái hợp lệ tồn tại.
Generics có ràng buộc
function groupBy<T, K extends PropertyKey>(items: T[], key: (t: T) => K): Record<K, T[]> {
return items.reduce((acc, it) => {
(acc[key(it)] ??= []).push(it);
return acc;
}, {} as Record<K, T[]>);
}
function pick<T, K extends keyof T>(obj: T, keys: K[]): Pick<T, K> { /* ... */ }
// Repository generic cho backend
interface Repo<T extends { id: string }> {
findById(id: T['id']): Promise<T | null>;
create(data: Omit<T, 'id'>): Promise<T>;
}
Mẹo đọc type thư viện: rê chuột trong IDE, dùng "Go to Type Definition", và đọc từ ràng buộc
(extends) trước — nó cho biết tác giả kỳ vọng gì.
Utility, mapped, conditional, template literal types
| Công cụ | Ví dụ | Dùng khi |
|---|---|---|
| Utility | Partial, Required, Pick, Omit, Record, ReturnType, Awaited, NonNullable | Hằng ngày: DTO cập nhật = Partial<CreateDto> |
| Mapped | { readonly [K in keyof T]: T[K] } | Biến đổi mọi field của một type |
| Conditional + infer | T extends Promise<infer U> ? U : T | Trích kiểu bên trong |
| Template literal | `on${Capitalize<E>}` | Tên sự kiện, route, key i18n |
satisfies | const routes = {...} satisfies Record<string, Route> | Kiểm tra mà vẫn giữ kiểu hẹp |
| Branded type | type UserId = string & { __brand: 'UserId' } | Không truyền nhầm ID |
Type-level programming 30
dòng mà không ai đọc nổi là nợ kỹ thuật. Mục tiêu là API dễ dùng, không phải type thông minh. Tránh
any; khi thực sự không biết, dùng unknown rồi narrow.
Kiểu ở compile-time, Zod ở runtime
TypeScript biến mất khi chạy. Dữ liệu từ request, form, env, API bên ngoài phải được validate tại biên. Zod cho bạn schema là nguồn sự thật duy nhất, type suy ra từ đó.
import { z } from 'zod';
export const CreateOrderSchema = z.object({
customerId: z.string().uuid(),
items: z.array(z.object({
productId: z.string().uuid(),
quantity: z.number().int().positive().max(100),
})).min(1),
couponCode: z.string().trim().toUpperCase().optional(),
});
export type CreateOrderInput = z.infer<typeof CreateOrderSchema>;
// Validate env một lần khi khởi động — thiếu biến thì chết sớm, không chết lúc 2h sáng
export const env = z.object({
DATABASE_URL: z.string().url(),
PORT: z.coerce.number().default(3000),
NODE_ENV: z.enum(['development', 'test', 'production']),
}).parse(process.env);
Cùng một schema dùng được ở form React (Module 11), ở API (Module 4) và trong monorepo chia sẻ
package @app/contracts (Module 17). Đây là xương sống "type-safe end-to-end".
🏋️ Bài tập thực hành
Chọn một API công khai (GitHub REST hoặc một API thanh toán sandbox). (1) Viết Zod schema cho 5
endpoint, suy ra type. (2) Viết client generic request<TSchema>(path, schema) trả về
type đúng, ném lỗi có cấu trúc khi response sai schema. (3) Dùng discriminated union cho kết quả
Result<T, E>. (4) Thêm branded type cho các loại ID. (5) Làm 15 bài trên
type-challenges mức easy + 5 bài medium. Bật toàn bộ cờ strict ở trên, không được dùng any.
📚 Tài nguyên học tập
-
TypeScript HandbookTài liệu chính thứcDocs
-
Total TypeScript (Matt Pocock)Bài viết và bài tập TS thực chiếnKhoá học
-
type-challengesBài tập type-level từ dễ đến cực khóRepo
-
ZodSchema validation có suy luận kiểuDocs
-
tsconfig referenceÝ nghĩa từng cờ cấu hìnhDocs
✅ Tự đánh giá hoàn thành
- Dự án bật strict + noUncheckedIndexedAccess, không có any
- Mô hình hóa trạng thái bằng discriminated union có exhaustive check
- Viết được generic có ràng buộc và đọc hiểu type của thư viện
- Mọi dữ liệu vào hệ thống đều qua Zod schema