TypeScript类型别名在交叉类型中的属性合并规则

TypeScript 中的交叉类型（Intersection Types）使用 & 符号，用于将多个类型合并为一个“超级类型”。理解其内部的属性合并规则，是避免类型错误的关键。以下是基于实际场景的详细操作指南。

1. 基础合并：不同属性的叠加

当两个类型拥有完全不同的属性时，交叉类型会简单地将它们“堆叠”在一起。新类型将拥有所有输入类型的属性。

1. 定义 两个具有不同属性的类型别名。

   type Person = {
     name: string;
   };

   type Contact = {
     email: string;
   };

2. 创建 交叉类型并 使用。

   type UserProfile = Person & Contact;

   const user: UserProfile = {
     name: "张三",
     email: "zhangsan@example.com"
   };

3. 确认 结果。UserProfile 类型必须同时包含 name 和 email 属性，缺一不可。

2. 冲突合并：原始类型属性的交集

当多个类型中存在同名属性，且这些属性的类型是原始类型（如 string、number）时，TypeScript 会计算它们的交集。

2.1 类型相同的情况

如果同名属性的类型完全一致，该属性会保留原类型。

1. 编写 如下代码，两个类型均包含 id 属性且类型均为 number。

   type Order = {
     id: number;
   };

   type Invoice = {
     id: number;
   };

   type Document = Order & Invoice;

2. 查看 结果。Document 中的 id 属性类型仍为 number。

2.2 类型不同的情况（关键规则）

如果同名属性的类型不同（例如一个是 string，另一个是 number），合并结果并非直接报错，而是变为 never。

1. 构建 两个类型，使其同名属性类型冲突。

   type TextResponse = {
     data: string;
   };

   type JsonResponse = {
     data: number;
   };

   type ApiResponse = TextResponse & JsonResponse;

2. 尝试 赋值。

   // 这里的 ApiResponse.data 类型为 never
   const response: ApiResponse = {
     data: "hello" // 错误：不能将类型 "string" 分配给类型 "never"
   };

3. 理解 原理。根据集合论，不存在一个值既是 string 又是 number，因此它们的交集为空集，即 never。这在实际开发中通常意味着类型定义逻辑有误。

3. 对象属性的深度合并

当同名属性本身也是对象时，TypeScript 会递归地对这些子对象进行交叉合并，而不是简单覆盖。

1. 定义 嵌套对象结构。

   type BaseConfig = {
     options: {
       theme: string;
     }
   };

   type AdvConfig = {
     options: {
       debug: boolean;
     }
   };

2. 合并 这两个类型。

   type AppConfig = BaseConfig & AdvConfig;

3. 分析 合并后的结构。AppConfig 的 options 属性将包含 theme 和 debug 两个子属性。

4. 赋值 验证。必须提供完整的嵌套对象结构。

   const config: AppConfig = {
     options: {
       theme: "dark",
       debug: true
     }
   };

4. 函数属性的合并（函数重载）

如果在交叉类型中合并函数签名（例如混合类接口），TypeScript 会将其处理为函数重载。

1. 创建 两个仅包含调用签名的类型。

   type StringLogger = {
     (msg: string): void;
   };

   type NumberLogger = {
     (msg: number): void;
   };

2. 生成 交叉类型。

   type Logger = StringLogger & NumberLogger;

3. 实现 该函数。函数本身无法同时满足两个签名，通常需要利用类型断言或重载签名来实现逻辑。

   // 只有当函数实现兼容所有重载时才有效
   // 这里展示的是类型定义层面的合并，实际运行时需要通过判断参数类型来执行不同逻辑
   const log: Logger = (msg: any) => {
     console.log(msg);
   };

4. 注意 顺序。在 TypeScript 内部处理中，交叉类型的成员顺序可能影响类型推断的优先级，但对于纯函数签名合并，最终表现为允许传入 string 或 number。

5. 合并逻辑的决策流程

为了快速判断属性合并的结果，可以参照以下逻辑流程。

6. 处理冲突的实用方案

在开发中，如果遇到原始类型冲突导致变为 never，通常需要显式处理。

1. 使用 Omit 工具类型 剔除 冲突属性。如果希望保留后定义的类型，可以先剔除前一个类型中的同名属性。

   type User = {
     id: string;
     role: string;
   };

   type Admin = {
     id: number; // 冲突属性
     permission: string;
   };

   // 剔除 User 中的 id，保留 Admin 的 id
   type SuperUser = Omit<User, 'id'> & Admin;

2. 验证 结果。SuperUser 中的 id 现在是 number 类型，且同时拥有 role 和 permission。

   const adminUser: SuperUser = {
     id: 1001,        // number
     role: "admin",   // string
     permission: "rw" // string
   };

3. 检查 最终代码。确保在赋值时，属性类型与合并后的定义严格一致。