泛型函数

示例

// example 1
export function get<T>(type: new () => T, index: number = 0): T {
    let tempArr = tempMap.get(type);
    if (!tempArr) {
        tempArr = [];
        tempMap.set(type, tempArr);
    }
    let value = tempArr[index];
    if (!value) {
        tempArr[index] = new type();
        value = tempArr[index];
    }
    return value;
}
// example 2
function firstElement<Type>(arr: Type[]): Type | undefined {
  return arr[0];
}

解释

T 是一个 泛型类型参数，它表示函数 get 可以处理任意类型的对象。具体来说，T 是一个占位符，在调用函数时会被具体的类型替换。

---

1. 泛型的作用

泛型（Generics）是 TypeScript 和许多其他编程语言中的一种特性，它允许我们编写可以处理多种类型的代码，而不需要为每种类型都写一个单独的函数。

在 get<T> 函数中：

• T 是一个类型变量，表示函数的返回值类型。
• 调用函数时，T 会被具体的类型替换。

---

2. T 的具体含义

在 get<T> 函数中，T 的具体含义取决于调用函数时传入的 type 参数。

示例 1：T 是 MyClass

class MyClass {
    constructor() {
        console.log('MyClass created');
    }
}

const obj = get(MyClass); // T 被推断为 MyClass

• 这里 T 是 MyClass，因为 type 参数是 MyClass 的构造函数。
• 函数返回值的类型是 MyClass。

示例 2：T 是 number

class NumberWrapper {
    value: number;
    constructor() {
        this.value = 0;
    }
}

const obj = get(NumberWrapper); // T 被推断为 NumberWrapper

• 这里 T 是 NumberWrapper，因为 type 参数是 NumberWrapper 的构造函数。
• 函数返回值的类型是 NumberWrapper。

---

3. new () => T 的含义

type: new () => T 是一个构造函数签名，表示 type 是一个可以创建 T 类型实例的构造函数。

• new ()：表示这是一个构造函数，调用时不需要参数。
• => T：表示构造函数返回的类型是 T。

示例

class MyClass {
    constructor() {
        console.log('MyClass created');
    }
}

function createInstance<T>(type: new () => T): T {
    return new type();
}

const obj = createInstance(MyClass); // T 被推断为 MyClass

• createInstance 函数接受一个构造函数 type，并返回一个 T 类型的实例。
• 调用 createInstance(MyClass) 时，T 被推断为 MyClass，返回值类型是 MyClass。

---

4. T 的动态性

T 的具体类型是在调用函数时动态确定的。这意味着 get 函数可以用于任何类型的对象，只要传入的 type 是一个合法的构造函数。

示例

class A {
    name = 'A';
}

class B {
    name = 'B';
}

const a = get(A); // T 是 A
const b = get(B); // T 是 B

• 第一次调用 get(A) 时，T 是 A。
• 第二次调用 get(B) 时，T 是 B。

---

5. 总结

• T 是一个泛型类型参数，表示函数可以处理任意类型。
• T 的具体类型由调用函数时传入的 type 参数决定。
• new () => T 表示 type 是一个无参数的构造函数，返回类型是 T。

通过泛型，get 函数可以灵活地处理多种类型的对象，而不需要为每种类型都写一个单独的函数。这种设计提高了代码的复用性和可维护性。

如果你还有其他问题，欢迎继续提问！