TypeScript类型兼容性

核心理念

TypeScript的核心特性之一：基于结构（形状）的类型系统

TypeScript关心的不是类型的名称，而是类型的形状。

typescript 复制代码

class Point1 { name: string; age: number; }
class Point2 { name: string; age: number; }

const p: Point1 = new Point2(); // 编译通过

尽管 Point1 和 Point2 是两个不同的类，但因为它们具有相同的形状，所以TypeScript认为它们是兼容的。

对象类型的兼容性：成员少的兼容成员多的

对于对象类型（包括类、接口），当赋值给一个要求更"宽泛"的类型时，源类型必须至少包含目标类型的所有必需属性。

typescript 复制代码

class Point1 { name: string; age: number; }
class Point2 { name: string; age: number; gender: string; } // 更"具体"的类型

const p: Point1 = new Point2(); // 编译通过！

这里，Point2（成员多）可以赋值给 Point1（成员少），因为 Point2 完全覆盖了 Point1 的所有要求。你可以理解为：Point1 的需求只是一个"子集"，而 Point2 提供的"超集"自然能够满足它。接口与类之间也遵循同样的规则。

函数类型的兼容性

函数类型的兼容性更为复杂，需要分别检查参数和返回值。

参数兼容性：参数多的兼容参数少的（逆变）
函数参数的类型检查遵循"逆变"原则。简单来说，你可以将一个接受更具体参数的函数（参数少），赋值给一个接受更宽泛参数的函数（参数多）。
typescript 复制代码
```
let handler1 = (arg: { name: string; age: number }) => { /* ... */ };
let handler2 = (arg: { name: string }) => { /* ... */ };

handler1 = handler2; // 编译通过
// handler2 只需要 `name`，而 handler1 提供的参数有 `name` 和 `age`，足够满足 handler2。
```
从集合论角度看，handler2 的参数类型是 handler1 参数类型的子集。将子集赋值给父集是安全的。原话中"参数多的兼容少的"是一种便于记忆的简化，其本质是逆变。

返回值兼容性：成员多的兼容成员少的（协变）

返回值的规则与对象类型类似，遵循"协变"。返回值类型需要更具体，即包含目标类型的所有成员。

typescript 复制代码

interface Animal { name: string; }
interface Dog extends Animal { breed: string; }

let getAnimal = (): Animal => ({ name: 'Generic Animal' });
let getDog = (): Dog => ({ name: 'Fido', breed: 'Labrador' });

getAnimal = getDog; // 编译通过
// 因为任何需要 Animal 的地方，得到一个拥有更多信息的 Dog 都是安全的。

交叉类型：类型的"合并"操作

交叉类型（&）用于将多个类型合并为一个类型，新类型将同时拥有所有类型的成员。它常用于组合对象类型。

typescript 复制代码

interface Person { name: string; }
interface Contact { phone: string; }
type PersonDetail = Person & Contact;

let obj: PersonDetail = {
    name: 'Jack',
    phone: '133...'
}; // 必须同时拥有 name 和 phone

与接口继承（extends）的关键区别：处理冲突的方式。

接口继承 ：如果子接口与父接口存在同名但类型不兼容的属性，会直接报错。
typescript 复制代码
```
interface A { fn: (value: number) => string; }
interface B extends A { fn: (value: string) => string; } // 错误
```

交叉类型 ：会将同名属性进行交叉，通常产生一个重载函数或联合类型。

typescript 复制代码

interface A { fn: (value: number) => string; }
interface B { fn: (value: string) => string; }
type C = A & B;
// 相当于：fn: ((value: number) => string) & ((value: string) => string);
// 在实践中，这通常意味着 fn 可以接受 number 或 string 参数。

总结

TypeScript的类型兼容性规则围绕着"形状"展开，其核心思想是保证类型安全的前提下提供灵活性。

对象：要满足对方的所有需求（目标类型是源类型的子集）。
函数参数：可以接受更宽泛的输入（逆变）。
函数返回值：需要提供更具体的输出（协变）。

思考题

假设有一个函数类型 type Processor = (data: string | number) => void，以及一个函数 const logger = (data: string) => { console.log(data); }。请问 const p: Processor = logger; 这个赋值是否成立？为什么？这反映了我们上面讨论的哪条规则？

typescript 复制代码

type Processor = (data: string | number) => void
const logger = (data: string) => { console.log(data); }
const p: Processor = logger//赋值是否成立？