Generics trong TypeScript là một công cụ mạnh mẽ cho phép bạn viết mã linh hoạt và có thể tái sử dụng. Thay vì cố định kiểu dữ liệu cho các hàm, class, hoặc interface, bạn có thể sử dụng generics để xác định kiểu tại thời điểm sử dụng, giúp mã của bạn trở nên linh hoạt hơn và an toàn hơn.

Bài viết này là một phần của chuỗi học TypeScript trên "codetuthub.com", cùng với các bài học khác như TypeScript Simple Types, TypeScript Functions, và TypeScript Enums.

1. Khái niệm về generics

Generics cho phép bạn định nghĩa một hoặc nhiều tham số kiểu trong các hàm, class, hoặc interface. Điều này có nghĩa là bạn có thể sử dụng các kiểu khác nhau mà không cần phải viết lại mã cho từng kiểu.

Ví dụ

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

console.log(identity<string>("Hello")); // Kết quả: "Hello"
console.log(identity<number>(42)); // Kết quả: 42

Trong ví dụ này, hàm identity nhận một tham số kiểu T và trả về giá trị của kiểu đó. Bạn có thể gọi hàm với bất kỳ kiểu dữ liệu nào.

2. Sử dụng generics với hàm

2.1 Định nghĩa hàm generics

Bạn có thể định nghĩa một hàm generics bằng cách thêm tham số kiểu vào tên hàm.

Ví dụ

ts
function getArray<T>(items: T[]): T[] {
    return new Array<T>().concat(items);
}

let numberArray = getArray<number>([1, 2, 3]);
let stringArray = getArray<string>(["Hello", "World"]);

Trong ví dụ này, hàm getArray nhận một mảng các phần tử kiểu T và trả về một mảng mới cùng kiểu.

3. Sử dụng generics với class

3.1 Định nghĩa class generics

Generics cũng có thể được sử dụng với các class, giúp tạo ra các class linh hoạt có thể làm việc với nhiều kiểu dữ liệu.

Ví dụ

ts
class GenericBox<T> {
    private content: T;

    constructor(value: T) {
        this.content = value;
    }

    getContent(): T {
        return this.content;
    }
}

let box = new GenericBox<string>("Hello, Generics!");
console.log(box.getContent()); // Kết quả: "Hello, Generics!"

Trong ví dụ này, class GenericBox chứa một thuộc tính content kiểu T, cho phép bạn tạo ra các đối tượng chứa bất kỳ kiểu dữ liệu nào.

4. Generics với interface

Bạn cũng có thể sử dụng generics trong các interface để định nghĩa cấu trúc linh hoạt.

Ví dụ

ts
interface KeyValuePair<K, V> {
    key: K;
    value: V;
}

let pair: KeyValuePair<number, string> = { key: 1, value: "One" };
console.log(pair); // Kết quả: { key: 1, value: "One" }

Trong ví dụ này, interface KeyValuePair có hai tham số kiểu K và V, cho phép bạn tạo ra các cặp khóa-giá trị với các kiểu khác nhau.

5. Ràng buộc generics

Bạn có thể ràng buộc các tham số kiểu bằng cách chỉ định các kiểu hoặc interface mà chúng phải tuân theo.

Ví dụ

ts
function logLength<T extends { length: number }>(arg: T): number {
    return arg.length;
}

console.log(logLength("Hello")); // Kết quả: 5
console.log(logLength([1, 2, 3])); // Kết quả: 3

Trong ví dụ này, hàm logLength chỉ nhận các tham số kiểu có thuộc tính length, cho phép bạn gọi hàm với chuỗi hoặc mảng.

6. Kết luận

Generics trong TypeScript là một công cụ mạnh mẽ giúp bạn viết mã linh hoạt và có thể tái sử dụng. Bằng cách sử dụng generics, bạn có thể định nghĩa các hàm, class, và interface có thể làm việc với nhiều kiểu khác nhau mà không làm mất tính an toàn của kiểu dữ liệu. Để tìm hiểu thêm về TypeScript, hãy tham khảo các bài học liên quan trên "codetuthub.com" như TypeScript Simple Types, TypeScript Functions, và TypeScript Classes.

Hy vọng bài viết này giúp bạn hiểu rõ về TypeScript Basic Generics và cách sử dụng chúng để cải thiện mã nguồn của bạn! Nếu có yêu cầu nào khác, vui lòng cho tôi biết!