依赖类型管理

依赖类型管理的基本概念

TypeScript中的依赖类型管理指的是在复杂系统中，如何通过类型系统表达和约束不同模块或组件之间的依赖关系。这种管理方式不仅限于简单的类型定义，更关注类型之间的关联性和交互规则。当项目规模扩大时，显式管理这些类型依赖能显著提高代码的可维护性和可靠性。

type UserID = string & { readonly brand: unique symbol };

interface User {
  id: UserID;
  name: string;
}

function getUser(id: UserID): Promise<User> {
  // 实现省略
}

类型别名与接口的依赖

基础类型依赖通常通过类型别名和接口建立。类型别名可以引用其他类型，形成明确的依赖链。接口扩展则是另一种建立类型依赖的方式，子接口会继承父接口的所有成员。

type Coordinate = {
  x: number;
  y: number;
};

type Movable = Coordinate & {
  velocity: number;
  direction: number;
};

interface Drawable {
  draw(ctx: CanvasRenderingContext2D): void;
}

interface Sprite extends Drawable {
  update(deltaTime: number): void;
}

泛型约束中的类型依赖

泛型参数可以依赖其他类型参数，形成更复杂的约束关系。通过extends关键字，可以确保泛型参数满足特定条件，这种约束在创建类型安全的容器或工具函数时特别有用。

type HasID = { id: string };

function mergeById<T extends HasID>(items: T[]): Record<string, T> {
  return items.reduce((acc, item) => {
    acc[item.id] = item;
    return acc;
  }, {} as Record<string, T>);
}

class Repository<T extends { id: K }, K> {
  private items = new Map<K, T>();

  add(item: T): void {
    this.items.set(item.id, item);
  }
}

条件类型与类型推断

条件类型允许基于输入类型动态决定输出类型，创建灵活的类型依赖。infer关键字可以在条件类型中提取嵌套类型信息，实现更精细的类型操作。

type UnpackPromise<T> = T extends Promise<infer U> ? U : T;

type A = UnpackPromise<Promise<string>>; // string
type B = UnpackPromise<number>; // number

type FirstArg<F> = F extends (arg: infer A, ...args: any[]) => any ? A : never;

type C = FirstArg<(name: string, age: number) => void>; // string

映射类型与键重映射

映射类型可以基于现有类型创建新类型，通过键重映射可以修改或过滤属性。这种技术常用于创建类型安全的工具类型，如部分类型、只读类型等。

type Optional<T> = {
  [P in keyof T]?: T[P];
};

type ReadonlyPartial<T> = {
  readonly [P in keyof T]?: T[P];
};

type Getters<T> = {
  [P in keyof T as `get${Capitalize<string & P>}`]: () => T[P];
};

type UserGetters = Getters<{ name: string; age: number }>;
// { getName: () => string; getAge: () => number }

类型谓词与自定义类型守卫

类型谓词允许开发者定义自己的类型守卫函数，这些函数可以在运行时检查类型，并在类型系统中建立依赖关系。这对于处理联合类型或未知输入特别有价值。

function isStringArray(value: unknown): value is string[] {
  return Array.isArray(value) && value.every(item => typeof item === 'string');
}

function processInput(input: unknown) {
  if (isStringArray(input)) {
    // 这里input被推断为string[]
    input.map(s => s.toUpperCase());
  }
}

模板字面量类型

TypeScript 4.1引入的模板字面量类型可以创建基于字符串模式的类型依赖。这种类型特别适合处理路由、CSS类名等字符串模式场景。

type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';

type ApiEndpoint = `/api/${string}`;

type ApiRoute = `${HttpMethod} ${ApiEndpoint}`;

function handleRoute(route: ApiRoute) {
  // 实现省略
}

handleRoute('GET /api/users'); // 合法
handleRoute('POST /api/products'); // 合法
handleRoute('PATCH /api/orders'); // 错误

类型级编程与递归类型

TypeScript支持一定程度的类型级编程，通过递归类型可以实现复杂的类型计算。这种技术常用于处理嵌套数据结构或构建类型安全的DSL。

type DeepReadonly<T> = {
  readonly [P in keyof T]: T[P] extends object ? DeepReadonly<T[P]> : T[P];
};

type Nested = {
  a: number;
  b: {
    c: string;
    d: {
      e: boolean;
    };
  };
};

type ReadonlyNested = DeepReadonly<Nested>;

type Json =
  | string
  | number
  | boolean
  | null
  | Json[]
  | { [key: string]: Json };

function parseJson(json: Json): unknown {
  return JSON.parse(JSON.stringify(json));
}

品牌类型与名义类型模拟

虽然TypeScript使用结构类型系统，但通过品牌模式可以模拟名义类型行为。这种技术可以创建互不兼容的类型，即使它们具有相同的结构。

type USD = number & { readonly _brand: 'USD' };
type EUR = number & { readonly _brand: 'EUR' };

function usd(amount: number): USD {
  return amount as USD;
}

function eur(amount: number): EUR {
  return amount as EUR;
}

function addUSD(a: USD, b: USD): USD {
  return usd(a + b);
}

const dollars = usd(100);
const euros = eur(100);

addUSD(dollars, dollars); // 合法
addUSD(dollars, euros); // 类型错误

类型兼容性与子类型关系

理解类型之间的兼容性规则对于管理类型依赖至关重要。TypeScript采用结构化类型系统，但某些情况下需要特别注意子类型关系。

interface Animal {
  name: string;
}

interface Dog extends Animal {
  breed: string;
}

let animal: Animal = { name: 'Animal' };
let dog: Dog = { name: 'Dog', breed: 'Labrador' };

animal = dog; // 合法，Dog是Animal的子类型
// dog = animal; // 错误，缺少breed属性

type Callback<T> = (value: T) => void;

let animalCallback: Callback<Animal> = (a: Animal) => console.log(a.name);
let dogCallback: Callback<Dog> = (d: Dog) => console.log(d.breed);

// 逆变位置的特殊行为
animalCallback = dogCallback; // 错误
dogCallback = animalCallback; // 合法

模块间的类型依赖

在大型项目中，管理跨模块的类型依赖尤为重要。合理使用import type可以避免运行时依赖，同时保持类型系统的完整性。

// types.ts
export type User = {
  id: string;
  name: string;
  email: string;
};

export type UserUpdate = Partial<Omit<User, 'id'>>;

// service.ts
import type { User, UserUpdate } from './types';

class UserService {
  private users: User[] = [];

  updateUser(id: string, update: UserUpdate): User | undefined {
    const user = this.users.find(u => u.id === id);
    if (user) {
      Object.assign(user, update);
    }
    return user;
  }
}

类型工具库的构建

随着项目复杂度增加，创建自定义类型工具库可以帮助管理重复出现的类型模式。这些工具类型可以显著减少样板代码。

type ValueOf<T> = T[keyof T];

type AsyncReturnType<T extends (...args: any) => any> = 
  ReturnType<T> extends Promise<infer U> ? U : ReturnType<T>;

type ActionTypes<T extends Record<string, (...args: any[]) => any>> = {
  [K in keyof T]: ReturnType<T[K]>;
}[keyof T];

type Reducer<S, A> = (state: S, action: A) => S;

function createReducer<S, A extends { type: string }>(
  initialState: S,
  handlers: {
    [K in A['type']]?: Reducer<S, Extract<A, { type: K }>>;
  }
): Reducer<S, A> {
  return (state = initialState, action) => {
    const handler = handlers[action.type];
    return handler ? handler(state, action as any) : state;
  };
}

类型安全的API通信

在前端与后端通信时，类型依赖可以确保API契约的一致性。通过共享类型定义或生成类型定义，可以避免前后端类型不匹配的问题。

// shared/api-types.ts
export interface ApiResponse<T> {
  data: T;
  error?: string;
  timestamp: number;
}

export interface User {
  id: string;
  name: string;
  email: string;
}

export type GetUserResponse = ApiResponse<User>;
export type UpdateUserRequest = Partial<Omit<User, 'id'>>;

// frontend/api.ts
import type { GetUserResponse, UpdateUserRequest } from 'shared/api-types';

async function getUser(id: string): Promise<GetUserResponse> {
  const response = await fetch(`/api/users/${id}`);
  return response.json();
}

async function updateUser(id: string, data: UpdateUserRequest): Promise<void> {
  await fetch(`/api/users/${id}`, {
    method: 'PUT',
    body: JSON.stringify(data),
    headers: { 'Content-Type': 'application/json' },
  });
}

类型依赖与性能考量

复杂的类型依赖可能会影响TypeScript编译器的性能。了解类型系统的实现细节有助于在类型安全和编译速度之间找到平衡。

// 简单的条件类型通常性能良好
type NonNullable<T> = T extends null | undefined ? never : T;

// 深层嵌套的条件类型可能导致性能问题
type DeepNonNullable<T> = {
  [P in keyof T]: T[P] extends object ? DeepNonNullable<T[P]> : NonNullable<T[P]>;
};

// 递归类型深度限制
type RecursiveArray<T> = T | RecursiveArray<T>[];
// 实际使用时应限制递归深度
type RecursiveArrayMaxDepth<T, D extends number> = 
  D extends 0 ? T : T | RecursiveArrayMaxDepth<T[], Subtract<D, 1>>;

// 实用工具类型，限制递归深度
type Subtract<A extends number, B extends number> = 
  // 实现省略，需要元组类型技巧

类型依赖与测试

类型测试可以验证复杂的类型依赖是否按预期工作。通过@ts-expect-error注释和工具如dtslint，可以创建类型级别的测试用例。

type Expect<T extends true> = T;
type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2
  ? true
  : false;

// 测试用例
type Test1 = Expect<Equal<UnpackPromise<Promise<string>>, string>>;
type Test2 = Expect<Equal<FirstArg<(a: number) => void>, number>>;

// @ts-expect-error 测试错误情况
type ErrorTest = Expect<Equal<string, number>>;

// 运行时类型检查测试
function assertType<T>(value: T): void {
  // 无操作，仅用于类型检查
}

const testUser = { id: '1', name: 'Test' };
assertType<User>(testUser); // 通过
// assertType<User>({ id: '1' }); // 错误，缺少name属性