泛型参数默认值

泛型参数默认值的基本概念

TypeScript中的泛型允许我们创建可重用的组件，这些组件可以处理多种类型而不是单一类型。泛型参数默认值进一步增强了这种灵活性，它允许我们在使用泛型时指定默认类型，当没有显式提供类型参数时就会使用这个默认值。

interface Box<T = string> {
  value: T;
}

const stringBox: Box = { value: "hello" };  // T默认为string
const numberBox: Box<number> = { value: 42 };

为什么需要泛型参数默认值

泛型参数默认值的主要目的是提高代码的可读性和减少冗余。当大多数情况下泛型参数都是某种特定类型时，设置默认值可以避免重复指定类型。这在大型代码库中尤其有用，可以减少样板代码并提高开发效率。

// 没有默认值
function fetchData<T>(url: string): Promise<T> {
  // ...
}

// 每次调用都需要指定类型
fetchData<User[]>('/api/users');

// 有默认值
function fetchData<T = any>(url: string): Promise<T> {
  // ...
}

// 可以省略类型参数
fetchData('/api/users');  // T默认为any

泛型参数默认值的语法

泛型参数默认值的语法与函数参数默认值类似，使用等号(=)指定默认类型。可以在泛型类型、接口、类和函数中使用。

// 接口中的泛型默认值
interface Response<T = any> {
  data: T;
  status: number;
}

// 类中的泛型默认值
class Container<T = string> {
  constructor(public value: T) {}
}

// 函数中的泛型默认值
function identity<T = number>(arg: T): T {
  return arg;
}

多个泛型参数与默认值

当有多个泛型参数时，可以为每个参数单独设置默认值。需要注意的是，带默认值的泛型参数必须放在不带默认值的参数后面。

// 正确：带默认值的参数在后
function merge<A, B = A>(a: A, b: B): A & B {
  return { ...a, ...b };
}

// 错误：带默认值的参数在前
function merge<A = any, B>(a: A, b: B): A & B {  // 报错
  return { ...a, ...b };
}

默认值与约束的结合使用

泛型参数默认值可以与类型约束一起使用，这提供了更大的灵活性。约束确保类型参数满足某些条件，而默认值提供了回退选项。

interface Lengthwise {
  length: number;
}

function logLength<T extends Lengthwise = string>(arg: T): void {
  console.log(arg.length);
}

logLength("hello");  // 使用默认值string
logLength([1, 2, 3]);  // 显式推断为number[]

复杂场景中的默认值

在更复杂的类型场景中，泛型默认值可以显著简化类型定义。特别是在嵌套泛型或高阶类型中，默认值可以减少类型参数的传递。

type ApiResponse<Data = any, Error = string> = {
  success: boolean;
  data?: Data;
  error?: Error;
};

// 使用部分默认值
const successResponse: ApiResponse<{ id: number }> = {
  success: true,
  data: { id: 1 }
};

// 使用全部默认值
const errorResponse: ApiResponse = {
  success: false,
  error: "Not found"
};

与条件类型的结合

泛型默认值可以与条件类型结合使用，创建更灵活的类型定义。这种组合特别适合需要根据输入类型动态确定输出类型的场景。

type ValueOrArray<T = string> = T extends Array<any> ? T : T[];

// 默认情况下处理string
const strings: ValueOrArray = ["a", "b"];  // string[]

// 显式指定类型
const numbers: ValueOrArray<number> = [1, 2];  // number[]
const arrays: ValueOrArray<number[]> = [[1], [2]];  // number[][]

在React组件中的应用

在React+TypeScript开发中，泛型默认值常用于组件props的类型定义，特别是当组件支持多种数据类型但大多数情况下使用特定类型时。

interface ListProps<T = string> {
  items: T[];
  renderItem: (item: T) => React.ReactNode;
}

// 默认处理字符串列表
function List<T = string>({ items, renderItem }: ListProps<T>) {
  return <div>{items.map(renderItem)}</div>;
}

// 使用默认类型
<List items={["a", "b"]} renderItem={(item) => <div>{item}</div>} />

// 自定义类型
<List<number> items={[1, 2]} renderItem={(item) => <div>{item}</div>} />

工具类型中的默认值应用

TypeScript内置的工具类型和一些常用工具类型库中广泛使用泛型默认值来提供更好的开发者体验。

// 模拟Partial的实现
type Partial<T = any> = {
  [P in keyof T]?: T[P];
};

// 使用默认值
const partialObj: Partial = { name: "John" };  // 相当于Partial<any>

// 自定义类型
const partialUser: Partial<User> = { id: 1 };

默认值的类型推断

当使用泛型默认值时，TypeScript的类型推断系统会智能地工作。如果没有提供类型参数，它会使用默认值；如果提供了部分参数，它会尽可能推断剩余参数。

function createPair<First = string, Second = number>(first: First, second: Second): [First, Second] {
  return [first, second];
}

// 完全使用默认值
const pair1 = createPair("hello", 42);  // [string, number]

// 部分指定类型
const pair2 = createPair<boolean>("hello", 42);  // 错误，第一个参数不是boolean
const pair3 = createPair<boolean>(true, 42);  // [boolean, number]

// 完全指定类型
const pair4 = createPair<number, string>(100, "test");  // [number, string]

默认值的限制与注意事项

虽然泛型默认值很强大，但使用时需要注意一些限制和潜在问题。了解这些可以帮助避免常见的陷阱。

1. 默认值顺序：带默认值的泛型参数必须放在不带默认值的参数后面。
2. 类型兼容性：默认值必须满足所有类型约束（如果有的话）。
3. 类型推断优先级：显式指定的类型参数会覆盖默认值。
4. 复杂默认值：避免使用过于复杂的类型作为默认值，这会降低代码可读性。

// 错误的顺序
function example<T = any, U>(arg1: T, arg2: U) {}  // 错误

// 正确的顺序
function example<U, T = any>(arg1: T, arg2: U) {}  // 正确

高级模式：递归默认值

在某些高级场景中，可以使用递归类型定义作为默认值，这为创建复杂但灵活的类型系统提供了可能。

type TreeNode<T = string> = {
  value: T;
  left?: TreeNode<T>;
  right?: TreeNode<T>;
};

// 默认字符串树
const stringTree: TreeNode = {
  value: "root",
  left: { value: "left" },
  right: { value: "right" }
};

// 数字树
const numberTree: TreeNode<number> = {
  value: 1,
  left: { value: 2 },
  right: { value: 3 }
};

与函数重载的对比

泛型参数默认值在某些场景下可以替代函数重载，提供更简洁的类型定义。两者各有优缺点，需要根据具体情况选择。

// 使用函数重载
function process(input: string): string;
function process(input: number): number;
function process(input: any): any {
  return input;
}

// 使用泛型默认值
function process<T = string>(input: T): T {
  return input;
}

// 泛型默认值版本更简洁，但重载可以提供更精确的类型关系

性能考量

虽然泛型默认值在编译时处理，不会影响运行时性能，但复杂的默认类型可能会增加类型检查时间。对于大型项目，应该权衡灵活性和编译性能。

// 简单的默认值对性能影响很小
type Simple<T = string> = T;

// 复杂的默认值可能增加类型检查时间
type Complex<T = Record<string, Record<string, Record<string, any>>>> = T;

与其他语言对比

TypeScript的泛型默认值与C#、Java等语言的实现类似，但有一些语法和行为上的差异。了解这些差异有助于从其他语言过渡到TypeScript。

// TypeScript
class Box<T = string> {}

// C#
class Box<T = string> {}  // 类似，但语法细节不同

// Java不支持泛型参数默认值