深入浅出TypeScript泛型编程从基础语法到高级应用提升代码复用性与类型安全性的实用技巧

威震华夏关云长 · 发表于 2025-10-2 14:10:00

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要登录才可以下载或查看，没有账号？立即注册

x

引言

TypeScript作为JavaScript的超集，为我们带来了静态类型检查的能力，大大提高了代码的可靠性和可维护性。在TypeScript的众多特性中，泛型（Generics）是一个尤为强大的工具，它允许我们在定义函数、类和接口时使用类型变量，从而创建可重用的、灵活且类型安全的代码组件。本文将深入探讨TypeScript泛型编程的各个方面，从基础语法到高级应用，帮助读者全面理解并掌握这一重要特性。

一、泛型基础概念

1. 什么是泛型

泛型是一种允许在定义函数、类或接口时使用类型变量的编程特性。通过泛型，我们可以编写适用于多种类型的代码，同时保持类型安全。简单来说，泛型就像是函数的类型参数，让我们能够创建”类型变量”，这些变量可以代表任何类型，在使用时再指定具体的类型。

2. 为什么需要泛型

在没有泛型的情况下，我们可能会使用any类型来处理多种类型的数据，但这会失去类型检查的优势。例如：

function identity(arg: any): any {
return arg;
}

复制代码

这个函数可以接受任何类型的参数并返回它，但我们失去了参数和返回值之间的类型关联。使用泛型，我们可以保持这种类型关系：

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

复制代码

这里，T是一个类型变量，它捕获了用户提供的类型，使我们能够在函数中使用它，并保持输入和输出之间的类型一致性。

3. 泛型的基本语法

泛型的基本语法是在函数名、类名或接口名后面使用尖括号<>来定义类型变量：

// 泛型函数
function functionName<T>(param: T): T {
// 函数体
}
// 泛型接口
interface InterfaceName<T> {
property: T;
method(param: T): T;
}
// 泛型类
class ClassName<T> {
property: T;
constructor(param: T) {
this.property = param;
}
method(): T {
return this.property;
}
}

复制代码

二、泛型函数

1. 基本泛型函数

让我们从最基本的泛型函数开始：

// 泛型函数示例
function identity<T>(arg: T): T {
return arg;
}
// 使用方式一：明确指定类型
let output1 = identity<string>("hello world");
console.log(output1); // "hello world"
// 使用方式二：类型推断（推荐）
let output2 = identity(42); // TypeScript推断T为number
console.log(output2); // 42

复制代码

在这个例子中，identity函数接受一个类型为T的参数，并返回一个相同类型的值。当我们调用这个函数时，可以明确指定类型，也可以让TypeScript根据传入的参数自动推断类型。

2. 多个类型参数

泛型函数可以有多个类型参数：

function pair<T, U>(first: T, second: U): [T, U] {
return [first, second];
}
let pairOutput = pair<string, number>("hello", 42);
console.log(pairOutput); // ["hello", 42]
// 使用类型推断
let pairOutput2 = pair(true, "world");
console.log(pairOutput2); // [true, "world"]

复制代码

3. 泛型函数与数组

泛型在处理数组时特别有用：

// 获取数组的第一个元素
function getFirstElement<T>(arr: T[]): T | undefined {
return arr.length > 0 ? arr[0] : undefined;
}
let numbers = [1, 2, 3, 4, 5];
let firstNumber = getFirstElement(numbers);
console.log(firstNumber); // 1
let strings = ["apple", "banana", "cherry"];
let firstString = getFirstElement(strings);
console.log(firstString); // "apple"
// 空数组情况
let emptyArray: number[] = [];
let emptyResult = getFirstElement(emptyArray);
console.log(emptyResult); // undefined

复制代码

4. 泛型函数与对象

泛型函数也可以处理对象：

function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
return obj[key];
}
interface Person {
name: string;
age: number;
address: string;
}
const person: Person = {
name: "John Doe",
age: 30,
address: "123 Main St"
};
let name = getProperty(person, "name");
console.log(name); // "John Doe"
let age = getProperty(person, "age");
console.log(age); // 30
// 以下代码会报错，因为"phone"不是Person的键
// let phone = getProperty(person, "phone");

复制代码

在这个例子中，我们使用了keyof关键字来约束K类型，确保key参数必须是T类型的键。

三、泛型接口

1. 基本泛型接口

泛型接口允许我们定义具有泛型类型的接口：

interface GenericIdentityFn<T> {
(arg: T): T;
}
function identity<T>(arg: T): T {
return arg;
}
let myIdentity: GenericIdentityFn<number> = identity;
console.log(myIdentity(10)); // 10

复制代码

2. 泛型接口与对象

泛型接口可以用于描述对象的形状：

interface Collection<T> {
add(item: T): void;
remove(item: T): boolean;
get(index: number): T | undefined;
size: number;
}
class ArrayCollection<T> implements Collection<T> {
private items: T[] = [];
add(item: T): void {
this.items.push(item);
}
remove(item: T): boolean {
const index = this.items.indexOf(item);
if (index !== -1) {
this.items.splice(index, 1);
return true;
}
return false;
}
get(index: number): T | undefined {
return this.items[index];
}
get size(): number {
return this.items.length;
}
}
// 使用字符串集合
const stringCollection = new ArrayCollection<string>();
stringCollection.add("hello");
stringCollection.add("world");
console.log(stringCollection.get(0)); // "hello"
console.log(stringCollection.size); // 2
// 使用数字集合
const numberCollection = new ArrayCollection<number>();
numberCollection.add(1);
numberCollection.add(2);
console.log(numberCollection.get(1)); // 2
console.log(numberCollection.size); // 2

复制代码

3. 泛型接口与函数

泛型接口可以用于描述函数类型：

interface SearchFunc<T> {
(source: T[], searchTerm: T): boolean;
}
let numberSearch: SearchFunc<number> = function(source, searchTerm) {
return source.indexOf(searchTerm) !== -1;
};
console.log(numberSearch([1, 2, 3, 4, 5], 3)); // true
console.log(numberSearch([1, 2, 3, 4, 5], 6)); // false
let stringSearch: SearchFunc<string> = function(source, searchTerm) {
return source.includes(searchTerm);
};
console.log(stringSearch(["apple", "banana", "cherry"], "banana")); // true
console.log(stringSearch(["apple", "banana", "cherry"], "grape")); // false

复制代码

四、泛型类

1. 基本泛型类

泛型类与泛型接口类似，使用类型参数来描述类的属性和方法：

class GenericNumber<T> {
zeroValue: T;
add: (x: T, y: T) => T;
constructor(zero: T, addFn: (x: T, y: T) => T) {
this.zeroValue = zero;
this.add = addFn;
}
}
let myGenericNumber = new GenericNumber<number>(0, (x, y) => x + y);
console.log(myGenericNumber.add(5, 10)); // 15
let stringNumeric = new GenericNumber<string>("", (x, y) => x + y);
console.log(stringNumeric.add("hello, ", "world")); // "hello, world"

复制代码

2. 泛型类与继承

泛型类可以继承其他类或实现接口：

interface Printable {
print(): void;
}
class Box<T> implements Printable {
private content: T;
constructor(content: T) {
this.content = content;
}
getContent(): T {
return this.content;
}
setContent(content: T): void {
this.content = content;
}
print(): void {
console.log(`Box contains: ${this.content}`);
}
}
class SpecialBox<T> extends Box<T> {
private specialProperty: string;
constructor(content: T, specialProperty: string) {
super(content);
this.specialProperty = specialProperty;
}
getSpecialProperty(): string {
return this.specialProperty;
}
print(): void {
super.print();
console.log(`Special property: ${this.specialProperty}`);
}
}
const numberBox = new Box<number>(42);
numberBox.print(); // "Box contains: 42"
const stringSpecialBox = new SpecialBox<string>("Hello", "This is special");
stringSpecialBox.print();
// "Box contains: Hello"
// "Special property: This is special"

复制代码

3. 泛型类与静态成员

需要注意的是，泛型类型不能用于类的静态成员：

class GenericClass<T> {
static staticProperty: T; // 错误：静态成员不能引用类类型参数
instanceProperty: T; // 正确：实例成员可以引用类类型参数
constructor(value: T) {
this.instanceProperty = value;
}
}

复制代码

五、泛型约束

1. 基本泛型约束

有时我们希望限制泛型类型必须满足某些条件，这时可以使用泛型约束：

interface Lengthwise {
length: number;
}
function loggingIdentity<T extends Lengthwise>(arg: T): T {
console.log(`Length: ${arg.length}`);
return arg;
}
loggingIdentity("hello world"); // 正确：字符串有length属性
loggingIdentity([1, 2, 3]); // 正确：数组有length属性
loggingIdentity({ length: 10, value: 3 }); // 正确：对象有length属性
// loggingIdentity(42); // 错误：数字没有length属性

复制代码

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

我们可以声明一个类型参数，且它被另一个类型参数所约束：

function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
return obj[key];
}
interface Person {
name: string;
age: number;
}
const person: Person = {
name: "Alice",
age: 30
};
let name = getProperty(person, "name"); // 类型为string
let age = getProperty(person, "age"); // 类型为number
// let phone = getProperty(person, "phone"); // 错误：'phone'不是'Person'的键

复制代码

3. 多重泛型约束

一个类型参数可以有多个约束：

interface Serializable {
serialize(): string;
}
interface Deserializable<T> {
deserialize(data: string): T;
}
class DataProcessor<T extends Serializable & Deserializable<T>> {
process(data: T): string {
return data.serialize();
}
restore(dataString: string): T {
const newData = {} as T;
return newData.deserialize(dataString);
}
}
class User implements Serializable, Deserializable<User> {
constructor(public name: string, public age: number) {}
serialize(): string {
return JSON.stringify({ name: this.name, age: this.age });
}
deserialize(data: string): User {
const obj = JSON.parse(data);
return new User(obj.name, obj.age);
}
}
const userProcessor = new DataProcessor<User>();
const user = new User("Bob", 25);
const serialized = userProcessor.process(user);
console.log(serialized); // {"name":"Bob","age":25}
const restoredUser = userProcessor.restore(serialized);
console.log(restoredUser.name); // "Bob"
console.log(restoredUser.age); // 25

复制代码

六、泛型工具类型

TypeScript提供了一些内置的泛型工具类型，可以帮助我们进行常见的类型转换。

1. Partial

Partial<T>将类型T的所有属性变为可选：

interface Todo {
title: string;
description: string;
completed: boolean;
}
function updateTodo(todo: Todo, fieldsToUpdate: Partial<Todo>): Todo {
return { ...todo, ...fieldsToUpdate };
}
const todo1: Todo = {
title: "Learn TypeScript",
description: "Study generics in TypeScript",
completed: false
};
const todo2 = updateTodo(todo1, {
description: "Study advanced generics in TypeScript"
});
console.log(todo2);
// {
// title: "Learn TypeScript",
// description: "Study advanced generics in TypeScript",
// completed: false
// }

复制代码

2. Required

Required<T>将类型T的所有属性变为必选：

interface Props {
a?: number;
b?: string;
}
const obj: Props = { a: 5 }; // 正确：a和b都是可选的
const obj2: Required<Props> = { a: 5 }; // 错误：b是必选的
const obj3: Required<Props> = { a: 5, b: "hello" }; // 正确

复制代码

3. Readonly

Readonly<T>将类型T的所有属性变为只读：

interface Todo {
title: string;
}
const todo: Readonly<Todo> = {
title: "Delete inactive users"
};
todo.title = "Hello"; // 错误：title是只读的

复制代码

4. Record

Record<K, T>创建一个对象类型，其属性键为K类型，属性值为T类型：

interface PageInfo {
title: string;
}
type Page = "home" | "about" | "contact";
const pages: Record<Page, PageInfo> = {
home: { title: "Home Page" },
about: { title: "About Us" },
contact: { title: "Contact Us" }
};
console.log(pages.home.title); // "Home Page"

复制代码

5. Pick

Pick<T, K>从类型T中选择一组属性K来创建新类型：

interface Todo {
title: string;
description: string;
completed: boolean;
}
type TodoPreview = Pick<Todo, "title" | "completed">;
const todo: TodoPreview = {
title: "Clean room",
completed: false
};
console.log(todo.title); // "Clean room"
console.log(todo.completed); // false
// console.log(todo.description); // 错误：description属性不存在

复制代码

6. Omit

Omit<T, K>从类型T中排除一组属性K来创建新类型：

interface Todo {
title: string;
description: string;
completed: boolean;
createdAt: number;
}
type TodoPreview = Omit<Todo, "description" | "createdAt">;
const todo: TodoPreview = {
title: "Clean room",
completed: false
};
console.log(todo.title); // "Clean room"
console.log(todo.completed); // false
// console.log(todo.description); // 错误：description属性不存在
// console.log(todo.createdAt); // 错误：createdAt属性不存在

复制代码

7. Exclude

Exclude<T, U>从类型T中排除可以赋值给U的类型：

type T0 = Exclude<"a" | "b" | "c", "a">; // "b" | "c"
type T1 = Exclude<"a" | "b" | "c", "a" | "b">; // "c"
type T2 = Exclude<string | number | (() => void), Function>; // string | number

复制代码

8. Extract

Extract<T, U>从类型T中提取可以赋值给U的类型：

type T0 = Extract<"a" | "b" | "c", "a" | "f">; // "a"
type T1 = Extract<string | number | (() => void), Function>; // () => void

复制代码

9. NonNullable

NonNullable<T>从类型T中排除null和undefined：

type T0 = NonNullable<string | number | undefined>; // string | number
type T1 = NonNullable<string[] | null | undefined>; // string[]

复制代码

10. ReturnType

ReturnType<T>获取函数类型T的返回类型：

type T0 = ReturnType<() => string>; // string
type T1 = ReturnType<(s: string) => void>; // void
type T2 = ReturnType<<T>() => T>; // {}
type T3 = ReturnType<<T extends U, U extends number[]>() => T>; // number[]
type T4 = ReturnType<any>; // any
type T5 = ReturnType<never>; // any
type T6 = ReturnType<string>; // 错误
type T7 = ReturnType<Function>; // any

复制代码

七、泛型的高级应用

1. 条件类型

条件类型允许我们根据条件选择类型，形式为T extends U ? X : Y：

type TypeName<T> =
T extends string ? "string" :
T extends number ? "number" :
T extends boolean ? "boolean" :
T extends undefined ? "undefined" :
T extends Function ? "function" :
"object";
type T0 = TypeName<string>; // "string"
type T1 = TypeName<"hello">; // "string"
type T2 = TypeName<42>; // "number"
type T3 = TypeName<true>; // "boolean"
type T4 = TypeName<undefined>; // "undefined"
type T5 = TypeName<() => void>; // "function"
type T6 = TypeName<{ a: number }>; // "object"

复制代码

2. 映射类型

映射类型允许我们基于旧类型创建新类型：

type OptionsFlags<T> = {
[Property in keyof T]: boolean;
};
interface Features {
darkMode: () => void;
newUserProfile: () => void;
}
type FeatureOptions = OptionsFlags<Features>;
// 等同于：
// {
// darkMode: boolean;
// newUserProfile: boolean;
// }

复制代码

3. 映射修饰符

我们可以使用+或-前缀来添加或移除修饰符：

// 移除只读属性
type CreateMutable<T> = {
-readonly [P in keyof T]: T[P];
};
interface LockedAccount {
readonly id: string;
readonly name: string;
}
type UnlockedAccount = CreateMutable<LockedAccount>;
// 等同于：
// {
// id: string;
// name: string;
// }
// 添加只读属性
type Locked<T> = {
+readonly [P in keyof T]: T[P];
};
type LockedAccount2 = Locked<{ id: string; name: string }>;
// 等同于：
// {
// readonly id: string;
// readonly name: string;
// }
// 添加可选属性
type Partial<T> = {
[P in keyof T]?: T[P];
};
// 移除可选属性
type Required<T> = {
[P in keyof T]-?: T[P];
};

复制代码

4. 模板字面量类型

TypeScript 4.1引入了模板字面量类型，它们可以通过字符串操作创建新的类型：

type EmailLocaleIDs = "welcome_email" | "email_heading";
type FooterLocaleIDs = "footer_title" | "footer_sendoff";
type AllLocaleIDs = `${EmailLocaleIDs | FooterLocaleIDs}_id`;
// 等同于：
// "welcome_email_id" | "email_heading_id" | "footer_title_id" | "footer_sendoff_id"

复制代码

5. 递归类型

TypeScript支持递归类型，允许类型引用自身：

type JsonValue =
| string
| number
| boolean
| null
| JsonObject
| JsonArray;
interface JsonObject {
[key: string]: JsonValue;
}
interface JsonArray extends Array<JsonValue> {}
const data: JsonValue = {
name: "John",
age: 30,
isStudent: false,
address: {
street: "123 Main St",
city: "New York"
},
hobbies: ["reading", "swimming"]
};

复制代码

6. 高阶函数与泛型

泛型在高阶函数中特别有用：

function map<T, U>(array: T[], fn: (item: T) => U): U[] {
const result: U[] = [];
for (const item of array) {
result.push(fn(item));
}
return result;
}
const numbers = [1, 2, 3, 4, 5];
const doubled = map(numbers, n => n * 2);
console.log(doubled); // [2, 4, 6, 8, 10]
const strings = ["hello", "world", "typescript"];
const lengths = map(strings, s => s.length);
console.log(lengths); // [5, 5, 10]

复制代码

7. 泛型与装饰器

泛型可以与装饰器结合使用，提供更灵活的元编程能力：

function logClass<T extends { new(...args: any[]): {} }>(constructor: T) {
return class extends constructor {
constructor(...args: any[]) {
super(...args);
console.log(`Creating instance of ${constructor.name}`);
}
};
}
@logClass
class Person {
constructor(public name: string) {}
}
const person = new Person("Alice"); // 输出: "Creating instance of Person"
console.log(person.name); // "Alice"

复制代码

八、实际项目中的泛型应用

1. API响应处理

在实际项目中，我们经常需要处理各种API响应，泛型可以帮助我们创建类型安全的响应处理逻辑：

interface ApiResponse<T> {
data: T;
status: number;
message: string;
timestamp: number;
}
interface User {
id: number;
name: string;
email: string;
}
interface Post {
id: number;
title: string;
content: string;
authorId: number;
}
async function fetchApi<T>(url: string): Promise<ApiResponse<T>> {
const response = await fetch(url);
const data = await response.json();
return {
data,
status: response.status,
message: response.statusText,
timestamp: Date.now()
};
}
// 获取用户数据
async function getUser(id: number): Promise<User> {
const response = await fetchApi<User>(`/api/users/${id}`);
return response.data;
}
// 获取文章数据
async function getPost(id: number): Promise<Post> {
const response = await fetchApi<Post>(`/api/posts/${id}`);
return response.data;
}
// 使用示例
getUser(1).then(user => {
console.log(user.name); // 类型安全，user被识别为User类型
});
getPost(1).then(post => {
console.log(post.title); // 类型安全，post被识别为Post类型
});

复制代码

2. 状态管理

在状态管理中，泛型可以帮助我们创建可重用的状态管理逻辑：

interface State<T> {
data: T | null;
loading: boolean;
error: Error | null;
}
class Store<T> {
private state: State<T> = {
data: null,
loading: false,
error: null
};
private listeners: Array<(state: State<T>) => void> = [];
getState(): State<T> {
return { ...this.state };
}
subscribe(listener: (state: State<T>) => void): () => void {
this.listeners.push(listener);
return () => {
this.listeners = this.listeners.filter(l => l !== listener);
};
}
private notify() {
this.listeners.forEach(listener => listener(this.getState()));
}
async load(loader: () => Promise<T>): Promise<void> {
this.state = {
data: null,
loading: true,
error: null
};
this.notify();
try {
const data = await loader();
this.state = {
data,
loading: false,
error: null
};
} catch (error) {
this.state = {
data: null,
loading: false,
error: error instanceof Error ? error : new Error(String(error))
};
}
this.notify();
}
}
// 使用示例
interface User {
id: number;
name: string;
}
const userStore = new Store<User>();
userStore.subscribe(state => {
if (state.loading) {
console.log("Loading user data...");
} else if (state.error) {
console.error("Error loading user data:", state.error.message);
} else if (state.data) {
console.log("User data loaded:", state.data.name);
}
});
// 模拟API调用
async function fetchUser(): Promise<User> {
return new Promise(resolve => {
setTimeout(() => {
resolve({ id: 1, name: "John Doe" });
}, 1000);
});
}
userStore.load(fetchUser);

复制代码

3. 表单处理

在表单处理中，泛型可以帮助我们创建类型安全的表单处理逻辑：

interface FormField<T> {
value: T;
error: string | null;
touched: boolean;
validate: (value: T) => string | null;
}
interface Form<T> {
fields: { [K in keyof T]: FormField<T[K]> };
isValid: boolean;
}
function createForm<T>(initialValues: T, validators: { [K in keyof T]?: (value: T[K]) => string | null }): Form<T> {
const fields: { [K in keyof T]: FormField<T[K]> } = {} as any;
for (const key in initialValues) {
const value = initialValues[key];
const validate = validators[key] || (() => null);
fields[key] = {
value,
error: null,
touched: false,
validate
};
}
return {
fields,
isValid: true
};
}
function updateField<T, K extends keyof T>(form: Form<T>, field: K, value: T[K]): Form<T> {
const updatedFields = { ...form.fields };
const fieldDef = updatedFields[field];
const error = fieldDef.validate(value);
updatedFields[field] = {
...fieldDef,
value,
error,
touched: true
};
const isValid = Object.values(updatedFields).every(f => !f.error);
return {
fields: updatedFields,
isValid
};
}
// 使用示例
interface LoginForm {
email: string;
password: string;
}
const loginForm = createForm<LoginForm>(
{ email: "", password: "" },
{
email: (value) => {
if (!value) return "Email is required";
if (!/\S+@\S+\.\S+/.test(value)) return "Email is invalid";
return null;
},
password: (value) => {
if (!value) return "Password is required";
if (value.length < 8) return "Password must be at least 8 characters";
return null;
}
}
);
// 更新表单字段
let updatedForm = updateField(loginForm, "email", "test@example.com");
updatedForm = updateField(updatedForm, "password", "password123");
console.log(updatedForm.isValid); // true
console.log(updatedForm.fields.email.error); // null
console.log(updatedForm.fields.password.error); // null

复制代码

4. 组件库开发

在开发React组件库时，泛型可以帮助我们创建灵活且类型安全的组件：

import React from 'react';
interface ListProps<T> {
items: T[];
renderItem: (item: T) => React.ReactNode;
keyExtractor: (item: T) => string | number;
className?: string;
}
function List<T>({ items, renderItem, keyExtractor, className }: ListProps<T>): React.ReactElement {
return (
<ul className={className}>
{items.map(item => (
<li key={keyExtractor(item)}>
{renderItem(item)}
</li>
))}
</ul>
);
}
interface User {
id: number;
name: string;
email: string;
}
interface Product {
id: string;
name: string;
price: number;
}
// 使用示例
const UserList: React.FC<{ users: User[] }> = ({ users }) => (
<List
items={users}
renderItem={user => (
<div>
<h3>{user.name}</h3>
<p>{user.email}</p>
</div>
)}
keyExtractor={user => user.id}
className="user-list"
/>
);
const ProductList: React.FC<{ products: Product[] }> = ({ products }) => (
<List
items={products}
renderItem={product => (
<div>
<h3>{product.name}</h3>
<p>${product.price.toFixed(2)}</p>
</div>
)}
keyExtractor={product => product.id}
className="product-list"
/>
);

复制代码

九、泛型编程的最佳实践

1. 使用有意义的类型参数名称

虽然使用单个大写字母（如T、U、K等）作为类型参数名称是常见的做法，但在某些情况下，使用更具描述性的名称可以提高代码的可读性：

// 不够清晰
function get<T>(array: T[], index: number): T | undefined {
return array[index];
}
// 更清晰
function getElement<Element>(array: Element[], index: number): Element | undefined {
return array[index];
}

复制代码

2. 限制泛型的范围

尽可能使用泛型约束来限制泛型的范围，这样可以提供更好的类型安全性和代码提示：

// 不够安全
function logLength<T>(arg: T): void {
// console.log(arg.length); // 错误：T不一定有length属性
}
// 更安全
function logLength<T extends { length: number }>(arg: T): void {
console.log(arg.length); // 正确：T有length属性
}

复制代码

3. 避免过度使用泛型

虽然泛型很强大，但并不是所有情况都需要使用泛型。过度使用泛型会使代码变得复杂且难以理解：

// 过度使用泛型
interface Pair<T, U> {
first: T;
second: U;
}
function createPair<T, U>(first: T, second: U): Pair<T, U> {
return { first, second };
}
// 更简单且足够
interface StringNumberPair {
first: string;
second: number;
}
function createStringNumberPair(first: string, second: number): StringNumberPair {
return { first, second };
}

复制代码

4. 提供默认类型参数

在适当的情况下，为泛型参数提供默认类型可以提高代码的灵活性：

interface ApiResponse<Data = any> {
data: Data;
status: number;
message: string;
}
// 使用默认类型
const response: ApiResponse = {
data: { name: "John" },
status: 200,
message: "OK"
};
// 指定类型
const userResponse: ApiResponse<User> = {
data: { id: 1, name: "John", email: "john@example.com" },
status: 200,
message: "OK"
};

复制代码

5. 使用泛型来创建可重用的工具函数

泛型非常适合创建可重用的工具函数：

// 通用数组去重函数
function unique<T>(array: T[], keyFn?: (item: T) => any): T[] {
const seen = new Set();
return array.filter(item => {
const key = keyFn ? keyFn(item) : item;
if (seen.has(key)) {
return false;
}
seen.add(key);
return true;
});
}
// 使用示例
const numbers = [1, 2, 3, 2, 1, 4];
const uniqueNumbers = unique(numbers);
console.log(uniqueNumbers); // [1, 2, 3, 4]
const users = [
{ id: 1, name: "John" },
{ id: 2, name: "Jane" },
{ id: 1, name: "John Doe" }
];
const uniqueUsers = unique(users, user => user.id);
console.log(uniqueUsers);
// [
// { id: 1, name: "John" },
// { id: 2, name: "Jane" }
// ]

复制代码

6. 在文档中说明泛型的用途

当创建复杂的泛型类型或函数时，提供清晰的文档说明泛型的用途和约束：

/**
* 过滤数组中的元素，保留满足条件的元素
* @param array 要过滤的数组
* @param predicate 判断元素是否应该保留的函数
* @returns 过滤后的新数组
* @template T 数组元素的类型
*/
function filter<T>(array: T[], predicate: (item: T) => boolean): T[] {
return array.filter(predicate);
}

复制代码

十、总结

TypeScript的泛型是一个强大的特性，它允许我们编写灵活、可重用且类型安全的代码。通过本文的学习，我们了解了泛型的基本概念、语法和用法，以及如何在函数、接口和类中使用泛型。我们还探讨了泛型约束、泛型工具类型以及泛型的高级应用，如条件类型、映射类型和模板字面量类型。

在实际项目中，泛型可以帮助我们处理API响应、状态管理、表单处理和组件开发等各种场景。通过遵循最佳实践，我们可以充分利用泛型的优势，编写出更加健壮、可维护的代码。

掌握TypeScript泛型编程需要时间和实践，但一旦理解了其核心概念和用法，你将能够编写出更加灵活、类型安全的代码，提高开发效率和代码质量。希望本文能够帮助你深入理解TypeScript泛型编程，并在实际项目中应用这些知识。

	通知：为庆祝网站一周年，将在5.1日与5.2日开放注册，具体信息请见后续详细公告	04-22 00:04
	通知：本站资源由网友上传分享，如有违规等问题请到版务模块进行投诉，资源失效请在帖子内回复要求补档，会尽快处理！	10-23 09:31

活动公告

深入浅出TypeScript泛型编程从基础语法到高级应用提升代码复用性与类型安全性的实用技巧

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

立华奏

站长推荐 /1

友情链接

Telegram

Discord

Tencent QQ