typescript | 青训营

在 TypeScript 中，泛型是一种强大的工具，用于增加代码的灵活性和安全性。它允许你编写可以适用于多种类型的代码，同时保持类型安全。下面是一些关于 TypeScript 类和泛型的使用实践记录，涵盖了泛型的基本用法、类型约束和一些常见场景。

基本泛型用法

1. 泛型函数

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

let output = identity<string>("hello");

2. 泛型接口

typescriptCopy code
interface GenericIdentityFn<T> {
    (arg: T): T;
}

let identityFn: GenericIdentityFn<number> = identity;

3. 泛型类

typescriptCopy code
class Container<T> {
    value: T;

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

let numberContainer = new Container<number>(42);

类型约束

使用泛型时，有时需要对泛型参数进行限制，以确保代码的正确性。

1. 使用 extends 进行类型约束

typescriptCopy code
function getProperty<T, K extends keyof T>(obj: T, key: K) {
    return obj[key];
}

let person = { name: "Alice", age: 30 };
let name = getProperty(person, "name");

2. 在泛型约束中使用类型

typescriptCopy code
function mergeObjects<T extends object, U extends object>(obj1: T, obj2: U): T & U {
    return { ...obj1, ...obj2 };
}

let merged = mergeObjects({ a: 1 }, { b: 2 });

泛型在实际场景中的应用

1. 数组操作函数

typescriptCopy code
function filter<T>(arr: T[], predicate: (item: T) => boolean): T[] {
    return arr.filter(predicate);
}

let numbers = [1, 2, 3, 4, 5];
let evenNumbers = filter(numbers, num => num % 2 === 0);

2. Promise 包装器

typescriptCopy code
function asyncWrapper<T>(promise: Promise<T>): Promise<[T | null, Error | null]> {
    return promise.then(data => [data, null]).catch(error => [null, error]);
}

let fetchData = async () => {
    // Fetch data from an API
};

let [data, error] = await asyncWrapper(fetchData());

3. 响应数据解析

typescriptCopy code
interface ApiResponse<T> {
    data: T;
    statusCode: number;
}

function parseApiResponse<T>(response: ApiResponse<T>): T {
    if (response.statusCode === 200) {
        return response.data;
    } else {
        throw new Error("Request failed");
    }
}

let response = {
    data: { name: "Alice", age: 30 },
    statusCode: 200
};

let userData = parseApiResponse(response);

泛型在 TypeScript 中的应用非常广泛，它们能够帮助你写出更加通用和类型安全的代码。通过合适的类型约束，你可以确保泛型代码在不同情境下都能正确运行，从而提高代码的质量和可维护性。