面试题：TypeScript 4.0+ 类型推断优化在复杂场景下的应用

Question

在TypeScript 4.0及更高版本中，类型推断得到了显著优化。请描述在大型代码库中，当涉及到泛型、条件类型、交叉类型和联合类型的复杂嵌套时，TypeScript是如何进行类型推断的。并且举例说明如何利用这些类型推断特性来简化代码，同时保证类型安全。此外，讨论在这种复杂场景下可能会遇到的类型推断陷阱以及如何避免。

Answer 1

TypeScript 在复杂嵌套类型中的类型推断

1. 泛型的类型推断：
   • 在TypeScript中，泛型允许创建可重用的组件，其类型参数可在使用时推断。例如，对于一个简单的函数 identity：

   function identity<T>(arg: T): T {
       return arg;
   }
   let result = identity(42); // result类型被推断为number
   

   • 在大型代码库中，泛型类型推断会根据函数调用时传入的参数类型来确定泛型参数的类型。如果有多个泛型参数，TypeScript会按照顺序依次推断，从左到右匹配函数参数类型。
2. 条件类型的类型推断：
   • 条件类型通过 T extends U? X : Y 的语法定义。例如：

   type IsString<T> = T extends string? true : false;
   type StringCheck = IsString<string>; // true
   type NumberCheck = IsString<number>; // false
   

   • 在复杂嵌套中，条件类型会根据类型约束来推断结果类型。例如，在一个根据不同类型返回不同值的函数中：

   function getValue<T>(arg: T): T extends string? number : string {
       if (typeof arg ==='string') {
           return 42 as any;
       } else {
           return 'default' as any;
       }
   }
   let stringResult = getValue('test'); // 推断为number
   let numberResult = getValue(123); // 推断为string
   

3. 交叉类型的类型推断：
   • 交叉类型 A & B 表示一个类型同时具有 A 和 B 的属性。例如：

   type A = { a: string };
   type B = { b: number };
   type AB = A & B;
   let ab: AB = { a: 'test', b: 42 };
   

   • 在复杂嵌套中，TypeScript会尝试合并两个或多个类型的属性。如果属性类型存在冲突，会报错。例如，若 A 和 B 都有同名属性但类型不同，就会导致类型错误。
4. 联合类型的类型推断：
   • 联合类型 A | B 表示一个类型可以是 A 或者 B。例如：

   type StringOrNumber = string | number;
   let value: StringOrNumber = 'test';
   value = 42;
   

   • 在函数参数为联合类型时，TypeScript会根据具体赋值来推断可能的操作。例如：

   function printValue(value: string | number) {
       if (typeof value ==='string') {
           console.log(value.length);
       } else {
           console.log(value.toFixed(2));
       }
   }
   

利用类型推断特性简化代码并保证类型安全

1. 泛型简化代码：
   • 以一个通用的数组处理函数为例：

   function mapArray<T, U>(arr: T[], callback: (item: T) => U): U[] {
       return arr.map(callback);
   }
   let numbers = [1, 2, 3];
   let squared = mapArray(numbers, (n) => n * n); // squared类型被推断为number[]
   

   • 这里使用泛型避免了为不同类型数组重复编写 map 函数，同时保证了类型安全。
2. 条件类型简化代码：
   • 假设我们有一个根据不同类型进行不同序列化的函数：

   type Serializable<T> = T extends string | number | boolean? T : string;
   function serialize<T>(value: T): Serializable<T> {
       if (typeof value === 'object') {
           return JSON.stringify(value) as any;
       }
       return value;
   }
   let obj = { key: 'value' };
   let serializedObj = serialize(obj); // serializedObj类型被推断为string
   let num = 42;
   let serializedNum = serialize(num); // serializedNum类型被推断为number
   

   • 条件类型在这里根据输入值的类型，简化了序列化逻辑，同时保证了类型安全。

复杂场景下的类型推断陷阱及避免方法

1. 泛型推断不明确：
   • 陷阱：当泛型参数在函数中没有足够的类型信息时，推断可能不明确。例如：

   function combine<T>(a: T, b: T) {
       return a + b;
   }
   let result = combine(1, 'test'); // 这里会报错，因为T的类型推断不明确
   

   • 避免方法：明确指定泛型参数类型，或者提供更多类型信息。例如：

   function combine<T extends string | number>(a: T, b: T) {
       return a + b;
   }
   let result = combine<string>('test', 'ing'); // 明确指定泛型类型
   

2. 条件类型的递归陷阱：
   • 陷阱：在定义条件类型时，如果不小心引入了无限递归，会导致编译错误。例如：

   type InfiniteRecursion<T> = T extends never? never : InfiniteRecursion<T>;
   // 这里会报错，因为存在无限递归
   

   • 避免方法：确保条件类型的递归有明确的终止条件。例如：

   type BaseType = string | number | boolean;
   type RecursiveCheck<T> = T extends BaseType? T : string;
   

3. 交叉类型和联合类型的冲突：
   • 陷阱：当交叉类型和联合类型混合使用时，可能会出现类型冲突难以理解的情况。例如：

   type A = { a: string };
   type B = { b: number };
   type UnionAB = A | B;
   type CrossAB = A & B;
   let value: UnionAB;
   let crossValue: CrossAB;
   value = { a: 'test' };
   crossValue = value as any; // 这里会丢失类型安全，因为UnionAB和CrossAB不兼容
   

   • 避免方法：仔细分析类型需求，确保在使用交叉类型和联合类型时，清楚它们的含义和相互作用。尽量避免在没有明确需求的情况下将联合类型赋值给交叉类型。