TypeScript 协变与逆变

type FooFunc = () => string;
type BarFunc = () => "literal types";
type BazFunc = (input: string) => number;

class Animal {
  asPet() {}
}
 
class Dog extends Animal {
  bark() {}
}
 
class Corgi extends Dog {
  cute() {}
}
 
// ✅ 子类型可以替换父类型
const animal: Animal = new Dog();
const dog: Dog = new Corgi();
 
// ❌ 父类型不能替换子类型
// const corgi: Corgi = new Dog(); // Error

function makeDogBark(dog: Dog) {
  dog.bark();
}
 
// ✅ 正确: 传入子类型
makeDogBark(new Corgi());
 
// ❌ 错误: 不能传入父类型
// makeDogBark(new Animal()); // Error: Property 'bark' is missing

基础类型关系: Corgi ≼ Dog ≼ Animal
 
包装后的类型关系:
 
协变(Covariance):
┌─────────────────────────────────┐
│ 如果 A ≼ B                      │
│ 则 Wrapper<A> ≼ Wrapper<B>     │
│ (关系保持一致)                   │
└─────────────────────────────────┘
 
逆变(Contravariance):
┌─────────────────────────────────┐
│ 如果 A ≼ B                      │
│ 则 Wrapper<B> ≼ Wrapper<A>     │
│ (关系发生逆转)                   │
└─────────────────────────────────┘

class Animal {
  asPet() {}
}
 
class Dog extends Animal {
  bark() {}
}
 
class Corgi extends Dog {
  cute() {}
}

type DogFactory = (args: Dog) => Dog;

function transformDogAndBark(dogFactory: DogFactory) {
  const dog = dogFactory(new Dog()); // 传入 Dog 实例
  dog.bark(); // 调用返回值的 bark 方法
}

// Animal -> Animal
// 返回值是 Animal,不能保证有 bark() 方法
type WrongReturn1 = (args: Animal) => Animal;
 
// Dog -> Animal
// 返回值是 Animal,不能保证有 bark() 方法
type WrongReturn2 = (args: Dog) => Animal;
 
// Corgi -> Animal
// 返回值是 Animal,不能保证有 bark() 方法
type WrongReturn3 = (args: Corgi) => Animal;

// Corgi -> Dog
// 参数需要 Corgi,但我们可能传入其他品种的狗
type WrongParam1 = (args: Corgi) => Dog;
 
// Corgi -> Corgi
// 参数需要 Corgi,但我们可能传入其他品种的狗
type WrongParam2 = (args: Corgi) => Corgi;

// Animal -> Dog ✅
// 参数能接受 Dog(因为 Dog 是 Animal 的子类型)
// 返回值是 Dog,能调用 bark()
type Valid1 = (args: Animal) => Dog;
 
// Animal -> Corgi ✅
// 参数能接受 Dog
// 返回值是 Corgi,能调用 bark()
type Valid2 = (args: Animal) => Corgi;
 
// Dog -> Corgi ✅
// 参数接受 Dog
// 返回值是 Corgi,能调用 bark()
type Valid3 = (args: Dog) => Corgi;

// Corgi ≼ Dog
// (T -> Corgi) ≼ (T -> Dog) ✅

type AsFuncReturnType<T> = (arg: unknown) => T;
 
// 成立: 返回值类型遵循协变
type CheckReturnType = AsFuncReturnType<Corgi> extends AsFuncReturnType<Dog>
  ? "Covariant" 
  : "Error";
// 结果: "Covariant"

// Dog ≼ Animal
// (Animal -> T) ≼ (Dog -> T) ✅

type AsFuncArgType<T> = (arg: T) => void;
 
// 成立: 参数类型遵循逆变
type CheckArgType = AsFuncArgType<Animal> extends AsFuncArgType<Dog>
  ? "Contravariant" 
  : "Error";
// 结果: "Contravariant"

类型层级关系:
    Animal (父类型)
       ↑
      Dog
       ↑
    Corgi (子类型)
 
函数返回值 - 协变:
    (T -> Corgi) ≼ (T -> Dog)
    关系保持: 子 -> 子, 父 -> 父
 
函数参数 - 逆变:
    (Animal -> T) ≼ (Dog -> T)  
    关系逆转: 父 -> 子, 子 -> 父

// 假设我们需要一个处理 Dog 的函数
type DogHandler = (dog: Dog) => void;
 
// ✅ 可以传入能处理 Animal 的函数
// 因为这个函数能处理所有动物,当然能处理 Dog
const animalHandler: DogHandler = (animal: Animal) => {
  animal.asPet();
};
 
// ❌ 不能传入只能处理 Corgi 的函数
// 因为这个函数可能依赖 Corgi 的特性
// 但我们可能会传入其他品种的狗
const corgiHandler: DogHandler = (corgi: Corgi) => {
  corgi.cute(); // 如果传入德牧,会出错
};

// 假设我们需要一个返回 Dog 的函数
type DogCreator = () => Dog;
 
// ✅ 可以传入返回 Corgi 的函数
// 因为 Corgi 是 Dog,满足所有 Dog 的要求
const corgiCreator: DogCreator = () => new Corgi();
 
// ❌ 不能传入返回 Animal 的函数
// 因为 Animal 不一定有 Dog 的所有特性
const animalCreator: DogCreator = () => new Animal();
// Error: Type 'Animal' is not assignable to type 'Dog'

// tsconfig.json
{
  "compilerOptions": {
    "strictFunctionTypes": true
  }
}

function fn(dog: Dog) {
  dog.bark();
}
 
type CorgiFunc = (input: Corgi) => void;
type AnimalFunc = (input: Animal) => void;
 
// strictFunctionTypes: false
const func1: CorgiFunc = fn; // ✅ 允许(双变)
const func2: AnimalFunc = fn; // ✅ 允许(双变)
 
// strictFunctionTypes: true
const func3: CorgiFunc = fn; // ❌ 错误(逆变检查)
const func4: AnimalFunc = fn; // ✅ 正确(逆变检查)

// func1 的赋值等价于: (Dog -> T) ≼ (Corgi -> T)
// 这是协变关系,在严格模式下不成立
 
// func2 的赋值等价于: (Dog -> T) ≼ (Animal -> T)  
// 这是逆变关系,在严格模式下成立

// ❌ Method 声明 - 使用双变检查
interface MethodStyle {
  func(arg: string): number;
  // 等价于: func: {(arg: string): number}
}
 
// ✅ Property 声明 - 使用逆变检查(需要开启 strictFunctionTypes)
interface PropertyStyle {
  func: (arg: string) => number;
}

// .eslintrc.json
{
  "rules": {
    "@typescript-eslint/method-signature-style": ["error", "property"]
  }
}

interface Array<T> {
  push(...items: T[]): number;
  // 如果是 property 声明并启用严格检查
  // push: (...items: T[]) => number;
}

// 假设启用严格逆变检查
const dogs: Dog[] = [new Dog()];
const animals: Animal[] = dogs; // ❌ 会报错!
 
// 原因分析:
// Dog[].push ≼ Animal[].push 是否成立?
// 等价于: (...items: Dog[]) => number ≼ (...items: Animal[]) => number
// 逆变检查: Dog[] ≼ Animal[] ? 不成立!

// ✅ 使用 method 声明,数组类型兼容
const dogs: Dog[] = [new Dog()];
const animals: Animal[] = dogs; // 正确

// ❌ 错误示例
type MouseEventHandler = (event: MouseEvent) => void;
 
const handler: MouseEventHandler = (event: UIEvent) => {
  // Error: UIEvent 缺少 MouseEvent 的特有属性
  console.log(event.clientX); // clientX 只存在于 MouseEvent
};
 
// ✅ 正确示例
const correctHandler: MouseEventHandler = (event: Event) => {
  // Event 是 MouseEvent 的父类型
  // 可以安全地处理 MouseEvent
  console.log(event.type);
};

// 数据转换函数类型
type Transformer<Input, Output> = (input: Input) => Output;
 
// 基础类型
type BaseData = { id: string };
type UserData = BaseData & { name: string };
type AdminData = UserData & { permissions: string[] };
 
// ✅ 正确使用协变(返回值)
const userTransformer: Transformer<BaseData, UserData> = (input) => ({
  ...input,
  name: "Unknown",
});
 
// ✅ 正确使用逆变(参数)
const adminTransformer: Transformer<UserData, AdminData> = (input) => ({
  ...input,
  permissions: [],
});
 
// 组合使用
type DataProcessor = Transformer<BaseData, AdminData>;
const processor: DataProcessor = (input) => ({
  id: input.id,
  name: "Admin",
  permissions: ["read", "write"],
});

// 异步数据加载器
type DataLoader<T> = (callback: (data: T) => void) => void;
 
// 基础类型
interface Response {
  status: number;
}
 
interface UserResponse extends Response {
  data: {
    name: string;
    email: string;
  };
}
 
// ✅ 正确使用
const loader: DataLoader<UserResponse> = (callback) => {
  // 模拟异步加载
  callback({
    status: 200,
    data: { name: "John", email: "john@example.com" },
  });
};
 
// 可以传入接受父类型回调的函数
const callback = (response: Response) => {
  console.log(response.status);
};
 
loader(callback); // ✅ 类型安全

// 服务接口
interface Logger {
  log(message: string): void;
}
 
interface Database {
  query(sql: string): any[];
}
 
// 依赖容器
type ServiceFactory<T> = (container: Container) => T;
 
interface Container {
  get<T>(factory: ServiceFactory<T>): T;
}
 
// ✅ 服务注册示例
const loggerFactory: ServiceFactory<Logger> = (container) => ({
  log: (msg) => console.log(msg),
});
 
// 更具体的容器类型
interface AppContainer extends Container {
  register<T>(token: string, factory: ServiceFactory<T>): void;
}
 
// 可以将 AppContainer 的工厂赋值给 Container 的工厂
// 因为参数遵循逆变
const appLoggerFactory: ServiceFactory<Logger> = (
  container: AppContainer
) => ({
  log: (msg) => console.log(`[${Date.now()}] ${msg}`),
});

// 函数装饰器
type Decorator<T extends any[], R> = (
  fn: (...args: T) => R
) => (...args: T) => R;
 
// 日志装饰器
const withLogging: Decorator<[string, number], void> = (fn) => {
  return (...args) => {
    console.log("Calling with:", args);
    fn(...args);
  };
};
 
// ✅ 可以用于更宽松的参数类型
const logDecorator: Decorator<[any, any], void> = (fn) => {
  return (...args) => {
    console.log("Logged:", args);
    fn(...args[0], args[1]);
  };
};

type StringHandler = (input: string) => void;
 
const handler: StringHandler = (input: any) => {
  console.log(input);
}; // ✅ 没问题
 
const handler2: StringHandler = (input: "literal") => {
  console.log(input);
}; // ❌ 报错

// ✅ 正确: 参数使用父类型或相同类型
const handler3: StringHandler = (input: string | number) => {
  if (typeof input === "string") console.log(input);
};

// tsconfig.json
{
  "compilerOptions": {
    "strict": true, // 自动启用 strictFunctionTypes
    // 或者单独启用
    "strictFunctionTypes": true
  }
}

function identity<T>(arg: T): T {
  return arg;
}
 
type StringIdentity = (arg: string) => string;
type NumberIdentity = (arg: number) => number;
 
const strId: StringIdentity = identity; // ✅
const numId: NumberIdentity = identity; // ✅
 
// 但这两个类型之间不兼容
const wrong: NumberIdentity = ((arg: string) => arg); // ❌

// identity<string> 实例化后的类型是 (arg: string) => string
// identity<number> 实例化后的类型是 (arg: number) => number
 
// 这两个实例化后的类型之间不兼容(兄弟类型关系)

// ✅ 读取 - 协变
const dogs: Dog[] = [new Dog()];
const animals: Animal[] = dogs; // 允许
 
// ❌ 写入 - 不变
animals.push(new Animal()); // 运行时可能导致问题!
 
// TypeScript 通过 method 声明来放宽这个限制
// 但在运行时可能会出现类型安全问题

type Union = string | number;
 
// 联合类型作为返回值 - 协变
type ReturnUnion = () => string | number;
type ReturnString = () => string;
 
const r1: ReturnUnion = (() => "hello") as ReturnString; // ✅
const r2: ReturnString = (() => "hello" as string | number); // ❌
 
// 联合类型作为参数 - 逆变
type ParamUnion = (input: string | number) => void;
type ParamString = (input: string) => void;
 
const p1: ParamUnion = ((input: string) => {}) as ParamString; // ❌
const p2: ParamString = ((input: string | number) => {}) as ParamUnion; // ✅

// ✅ 推荐: 使用 property 声明
interface GoodInterface {
  // 回调函数、事件处理器等
  onClick: (event: MouseEvent) => void;
  onSuccess: (data: Response) => void;
  onError: (error: Error) => void;
}
 
// ❌ 避免: 使用 method 声明(除非有特殊需求)
interface AvoidInterface {
  onClick(event: MouseEvent): void;
}

// ✅ 好的设计: 参数宽松,返回值严格
type GoodFunc = (input: Base) => Specific;
 
// ❌ 不好的设计: 参数严格,返回值宽松
type BadFunc = (input: Specific) => Base;

// 验证类型兼容性的工具类型
type IsAssignable<T, U> = T extends U ? true : false;
 
// 验证协变
type IsCovariant<T, U> = IsAssignable<
  () => T,
  () => U
>;
 
// 验证逆变
type IsContravariant<T, U> = IsAssignable<
  (arg: U) => void,
  (arg: T) => void
>;
 
// 使用示例
type Test1 = IsCovariant<Corgi, Dog>; // true
type Test2 = IsContravariant<Animal, Dog>; // true

// tsconfig.json
{
  "compilerOptions": {
    "strict": true,
    "strictFunctionTypes": true,
    "noImplicitAny": true
  }
}

// .eslintrc.json
{
  "rules": {
    "@typescript-eslint/method-signature-style": ["error", "property"],
    "@typescript-eslint/strict-boolean-expressions": "error"
  }
}

// ✅ 在明确知道类型安全时使用双重断言
const handler: (input: string) => void = 
  ((input: unknown) => {
    if (typeof input === "string") {
      console.log(input);
    }
  }) as (input: string) => void;
 
// ❌ 避免滥用断言绕过类型检查
const bad = ((input: number) => input) as any as (input: string) => string;

参数逆变要宽松,返回协变要严格。
父类参数能接受,子类返回可提供。
严格检查开配置,property 声明更安全。

type Union = string | number;
 
// ✅ 协变示例
type CovariantExample = () => string;
const covariant: () => Union = (() => "hello") as CovariantExample;
 
// ✅ 逆变示例
type ContravariantExample = (input: Union) => void;
const contravariant: (input: string) => void = ((input: Union) => {}) as ContravariantExample;

class Cat extends Animal {
  meow() {}
}
 
// ❌ 兄弟类型之间不兼容
type DogFunc = (dog: Dog) => void;
type CatFunc = (cat: Cat) => void;
 
const dogFunc: DogFunc = (cat: Cat) => {}; // Error
const catFunc: CatFunc = (dog: Dog) => {}; // Error

interface Cage<T> {
  value: T;
  add(item: T): void;
}

interface ReadonlyCage<T> {
  readonly value: T;
  // 没有 add 方法
}
 
// ✅ 协变成立
const dogCage: ReadonlyCage<Dog> = { value: new Dog() };
const animalCage: ReadonlyCage<Animal> = dogCage; // OK

interface WriteOnlyCage<T> {
  add(item: T): void;
}
 
// ❌ 不变
const dogCage: WriteOnlyCage<Dog> = {
  add: (dog: Dog) => {}
};
const animalCage: WriteOnlyCage<Animal> = dogCage; // Error!
 
// 因为:
// animalCage.add(new Animal()); // 类型不安全

// ❌ 既不能协变也不能逆变
const dogCage: Cage<Dog> = {
  value: new Dog(),
  add: (dog: Dog) => {}
};
const animalCage: Cage<Animal> = dogCage; // Error

interface Array<T> {
  // 读取 - 协变位置
  [index: number]: T;
  readonly length: number;
  
  // 写入 - 不变位置
  push(...items: T[]): number;
}
 
// 实际上,数组在读取时是协变的
const dogs: Dog[] = [new Dog()];
const animals: Animal[] = dogs; // ✅ 允许,但类型不安全
 
// TypeScript 通过 method 声明来放宽写入的限制

// 假设的语法(TypeScript 不支持)
interface Covariant<out T> {
  // T 只能出现在输出位置
  getValue(): T;
}
 
interface Contravariant<in T> {
  // T 只能出现在输入位置
  setValue(value: T): void;
}

// 协变类型
type Producer<T> = () => T;
 
// 逆变类型
type Consumer<T> = (value: T) => void;
 
// 不变类型
type Container<T> = {
  get(): T;
  set(value: T): void;
};

// 函数重载的类型检查
interface Overloaded {
  (input: string): string;
  (input: number): number;
}
 
const fn: Overloaded = (input: string | number) => {
  return input;
};
 
// 重载类型的兼容性检查更加严格

type Conditional<T> = T extends string 
  ? (input: string) => T 
  : (input: number) => T;
 
// 条件类型的变型分析很复杂,需要具体实例化后判断

interface Person {
    name: string;
    age: number;
}
 
interface Guang extends Person {
    hobbies: string[];
}
 
// 函数参数的双向协变示例
let printHobbies: (guang: Guang) => void;
let printName: (person: Person) => void;
 
// strictFunctionTypes: false 时，两种赋值都可以：
// printName = printHobbies; // ✅ 双向协变时允许（但不安全！）
// printHobbies = printName; // ✅ 双向协变时允许（安全）
 
// strictFunctionTypes: true 时，只有逆变允许：
// printName = printHobbies; // ❌ 严格模式下报错（协变方向）
// printHobbies = printName; // ✅ 严格模式下正确（逆变方向）

// ❌ 双向协变的风险
const printHobbiesFn = (guang: Guang) => {
    console.log(guang.hobbies); // 访问 Guang 特有属性
};
 
// 如果允许双向协变：
let printPerson: (person: Person) => void = printHobbiesFn;
printPerson({ name: 'test', age: 20 }); // 运行时错误！hobbies 不存在

// 不变示例：非父子类型之间无法赋值
interface Dog {
    bark(): void;
}
 
interface Cat {
    meow(): void;
}
 
// Dog 和 Cat 是兄弟类型，不是父子类型
// 它们之间是不变的，不能互相赋值
const dog: Dog = { bark() {} };
// const cat: Cat = dog; // ❌ 报错：类型不兼容
 
// 泛型容器的不变性
interface Container<T> {
    get(): T;
    set(value: T): void;
}
 
// Container<Dog> 和 Container<Cat> 也是不变的
// const dogContainer: Container<Dog> = ...;
// const catContainer: Container<Cat> = dogContainer; // ❌ 报错

// 只读容器 → 协变（可读不可写，子类型可赋值给父类型）
interface ReadonlyContainer<T> {
    readonly value: T;
}
 
const dogReadonly: ReadonlyContainer<Dog> = { value: { bark() {} } };
// const animalReadonly: ReadonlyContainer<Animal> = dogReadonly; // ✅ 协变
 
// 只写容器 → 逆变（可写不可读，父类型可赋值给子类型）
interface WriteOnlyContainer<T> {
    set(value: T): void;
}
 
// 读写容器 → 不变（既读又写，类型必须完全一致）
interface ReadWriteContainer<T> {
    get(): T;
    set(value: T): void;
}
 
// ReadWriteContainer<Dog> 和 ReadWriteContainer<Animal> 之间不变
// 不能互相赋值