Vì sao nên dùng generics trong TypeScript?

Generics cho phép một hàm hoặc component làm việc với nhiều kiểu dữ liệu mà vẫn giữ được thông tin kiểu chính xác.

Khi nào nên giới hạn một generic?

Hãy thêm constraint khi phần cài đặt phụ thuộc vào một thuộc tính hoặc khả năng xác định của kiểu dữ liệu.

Mastering TypeScript Generics

Generics¹ là một trong những tính năng mạnh nhất của TypeScript. Chúng cho phép bạn viết code linh hoạt, có thể tái sử dụng trong khi vẫn duy trì type safety.

Generics là gì?

Generics cho phép bạn tạo các component hoạt động với nhiều types thay vì chỉ một type duy nhất. Hãy nghĩ về chúng như các type variables có thể được chỉ định khi component được sử dụng.

Function Generic cơ bản

function identity<T>(arg: T): T {
  return arg
}

const result = identity<string>('hello')

Generic Constraints

Bạn có thể constrain generics để đảm bảo chúng có một số properties nhất định:

interface HasLength {
  length: number
}

function logLength<T extends HasLength>(arg: T): T {
  console.log(arg.length)
  return arg
}

Generic Interfaces

interface ApiResponse<T> {
  data: T
  status: number
  message: string
}

interface User {
  id: number
  name: string
}

const response: ApiResponse<User> = {
  data: { id: 1, name: 'John' },
  status: 200,
  message: 'Success',
}

Ví dụ thực tế: Repository Pattern

interface Repository<T> {
  findById(id: string): Promise<T | undefined>
  findAll(): Promise<T[]>
  create(item: T): Promise<T>
}

class UserRepository implements Repository<User> {
  async findById(id: string): Promise<User | undefined> {
    // Implementation
    return undefined
  }

  async findAll(): Promise<User[]> {
    return []
  }

  async create(item: User): Promise<User> {
    return item
  }
}