Skip to content

条件类型深入实践

中等 约 40 分钟

你将构建什么

一个工具类型库,实现 Exclude、Extract、NonNullable 以及自定义的 Awaited 类型,递归解包 Promise<T>。

学习目标

  • 理解条件类型语法 T extends U ? X : Y
  • 从零构建 Exclude 和 Extract
  • 在联合类型上使用分布式条件类型
  • 实现递归类型解包(Awaited)

前置要求

  • 泛型类型
  • 联合类型与交叉类型
  • 类型别名

步骤

  1. 1

    构建 Exclude 和 Extract

    Exclude<T, U> 从 T 中移除可赋值给 U 的类型。Extract<T, U> 保留它们。两者都使用联合类型上的分布式条件类型。

    代码
    type MyExclude<T, U> = T extends U ? never : T;
    type MyExtract<T, U> = T extends U ? T : never;
    
    type T1 = MyExclude<'a' | 'b' | 'c', 'a'>;      // 'b' | 'c'
    type T2 = MyExtract<string | number | boolean, number>; // number
    
    type T3 = MyExclude<string | null | undefined, null | undefined>; // string

    预期结果

    T1 为 'b' | 'c',T2 为 number,T3 为 string —— 悬停即可验证。

  2. 2

    构建 NonNullable

    NonNullable<T> 从 T 中移除 null 和 undefined。使用你自己的 MyExclude 来实现它。

    代码
    type MyNonNullable<T> = MyExclude<T, null | undefined>;
    
    type T4 = MyNonNullable<string | null>;        // string
    type T5 = MyNonNullable<number | undefined>;   // number
    type T6 = MyNonNullable<string | null | undefined>; // string

    预期结果

    T4、T5、T6 都排除了 null 和 undefined。

  3. 3

    构建递归 Awaited 类型

    Awaited<T> 递归解包嵌套的 Promise:Awaited<Promise<Promise<number>>> 为 number。使用检查 .then 方法的条件类型。

    代码
    type MyAwaited<T> = T extends null | undefined ? T :
      T extends object & { then(onfulfilled: infer F, ...args: infer _): any; } ?
        F extends (value: infer V, ...args: infer _) => any ?
          MyAwaited<V> : never
      : T;
    
    type T7 = MyAwaited<Promise<number>>;           // number
    type T8 = MyAwaited<Promise<Promise<string>>>;  // string
    type T9 = MyAwaited<number>;                    // number

    预期结果

    T7 为 number,T8 为 string(递归解包),T9 为 number(无 Promise)。

  4. 4

    构建类型级 XOR

    创建一个类型,要求恰好拥有两个属性中的一个 —— 即类型级别的异或(XOR)。这在「要么 A 要么 B,但不能同时拥有」的 API 中很有用。

    代码
    type Without<T, U> = { [P in MyExclude<keyof T, keyof U>]?: never };
    type XOR<T, U> = (Without<T, U> & U) | (Without<U, T> & T);
    
    interface CatOptions { meow: boolean; }
    interface DogOptions { bark: boolean; }
    
    type PetOptions = XOR<CatOptions, DogOptions>;
    
    const a: PetOptions = { meow: true };     // OK
    const b: PetOptions = { bark: true };     // OK
    const c: PetOptions = { meow: true, bark: true }; // Error: can't have both
    const d: PetOptions = {};                  // Error: must have one

    预期结果

    只允许 meow 或 bark 中的一个;同时拥有或都不拥有会引发类型错误。

  5. 5

    使用类型断言测试

    使用类型级断言(通过带显式类型的 const 变量)验证你的工具类型产生预期结果。编译器就是你的测试运行器。

    代码
    // Type-level test: if these compile, the types are correct
    const _t1: 'b' | 'c' = {} as MyExclude<'a' | 'b' | 'c', 'a'>;
    const _t2: number = {} as MyNonNullable<number | null>;
    const _t3: string = {} as MyAwaited<Promise<Promise<string>>>;
    
    console.log('All type tests passed');

    预期结果

    文件编译无类型错误,确认工具类型工作正常。

自己动手试试

你学到了什么

你掌握了条件类型 —— Exclude、Extract、NonNullable 和 Awaited 背后的引擎。它们让你在编译时从其他类型计算出新类型。

相关资源

相关课程

查阅不认识的术语

新手友好的术语表用大白话解释编程术语——变量、函数、DOM、Promise 等等。

查看术语表

解读错误信息

用大白话解释常见错误——什么意思、为什么发生、如何修复。

查看错误

← 返回主题