Generics

Giả sử mèo con viết hàm "lấy phần tử đầu của mảng". Nếu nhận any[], hàm dùng được cho mọi mảng, nhưng kết quả là any - mất sạch kiểu, hết an toàn. Nếu viết riêng cho từng kiểu thì lặp code. Generics giải bài toán này: tham số hoá kiểu, để hàm tái dùng được mà vẫn giữ kiểu:

function dauTienAny(arr: any[]): any {
  return arr[0];
}
const x = dauTienAny([1, 2, 3]);   // x: any -> mat thong tin

function dauTien<T>(arr: T[]): T {
  return arr[0];
}
const y = dauTien([1, 2, 3]);      // y: number -> TS suy ra T = number

• ▸any cho dùng cho mọi kiểu nhưng làm mất thông tin kiểu ở đầu ra.
• ▸Generic <T> là một "ô trống" cho kiểu, được điền khi gọi hàm.
• ▸Nhờ T, đầu vào và đầu ra được nối kiểu với nhau - tái dùng mà vẫn an toàn.

Đặt <T> trước danh sách tham số là khai báo một tham số kiểu. Điều hay nhất: thường mèo con không phải ghi T khi gọi - TypeScript tự suy ra từ giá trị truyền vào, đúng tinh thần suy luận kiểu ở Bài 2:

function ghepDoi<T>(x: T): [T, T] {
  return [x, x];
}
console.log(ghepDoi("bo"), ghepDoi(7));
// ghepDoi("bo") -> [string, string]; ghepDoi(7) -> [number, number]

[ 'bo', 'bo' ] [ 7, 7 ]

• ▸<T> trước tham số khai báo một tham số kiểu cho hàm.
• ▸TypeScript thường tự suy ra T từ đối số, không cần ghi <T> khi gọi.
• ▸Kết quả mang đúng kiểu cụ thể theo cái đã truyền vào.

Một <T> tự do thì trong hàm bạn gần như không làm gì được với nó (vì T có thể là bất cứ kiểu nào). Ràng buộc bằng extends nói "T phải có ít nhất hình dạng này", mở khoá cho bạn dùng phần đó an toàn:

function doDai<T extends { length: number }>(x: T): number {
  return x.length;   // an toan: T chac chan co length
}
doDai("meo");        // OK - string co length
doDai([1, 2, 3]);    // OK - array co length
doDai(42);           // Loi - number khong co length

error TS2345: Argument of type 'number' is not assignable to parameter of type '{ length: number; }'.

• ▸<T extends Hinh> giới hạn T phải khớp (là con của) một hình dạng.
• ▸Trong hàm, bạn được dùng các phần mà ràng buộc bảo đảm có.
• ▸Truyền giá trị không khớp ràng buộc thì tsc báo lỗi ngay (TS2345).

Không chỉ hàm, cả interface, type và class đều nhận tham số kiểu. Và một tham số kiểu có thể có giá trị mặc định (default type parameter) để khi không ghi thì dùng cái mặc định:

interface Hop<T> {
  giaTri: T;
}
const h: Hop<string> = { giaTri: "bo" };

type DanhSach<T = string> = T[];   // mac dinh T = string
const ds: DanhSach = ["a", "b"];   // khong ghi <...> -> T la string

console.log(h.giaTri, ds.length);

bo 2

• ▸interface/type/class đều có thể nhận tham số kiểu, vd Hop<T>, Mang<T>.
• ▸Tham số kiểu mặc định (T = string) cho phép bỏ qua khi không cần đổi.
• ▸Generics là cách các thư viện (Array<T>, Promise<T>, Map<K, V>) hoạt động.

Generics chính là "hàm cho kiểu": bạn truyền kiểu vào như truyền giá trị, và nhận lại một kiểu mới. Đây là nền của mọi thư viện TypeScript chuyên nghiệp. Từ đây, ta bước vào phần thú vị nhất: lập trình hẳn ở tầng kiểu.