TypeScript进阶秘籍：类型体操的108种姿势

// 条件类型（Conditional Types）
type IsString<T> = T extends string ? true : false

// 映射类型（Mapped Types）
type Optional<T> = {
  [K in keyof T]?: T[K]
}

// 模板字面量类型（Template Literal Types）
type HttpMethod = `GET` | `POST` | `PUT` | `DELETE`

// 自定义类型守卫
const isServerError = (code: number): code is 500 | 503 => {
  return code === 500 || code === 503
}

// 使用场景
const handleResponse = (status: number) => {
  if (isServerError(status)) {
    console.error('服务器异常:', status)
  } else {
    console.log('正常状态码:', status)
  }
}

// 定义基础响应结构
type BaseResponse<T = unknown> = {
  code: number
  message: string
  data: T
  timestamp: number
}

// 分页数据结构
type Pagination<T> = {
  list: T[]
  total: number
  pageSize: number
  currentPage: number
}

// 组合使用示例
type UserListResponse = BaseResponse<Pagination<{
  id: string
  name: string
  email: string
}>>

// 动态路由参数类型推导
type ExtractParams<Path extends string> = 
  Path extends `${string}:${infer Param}/${infer Rest}`
    ? { [K in Param | keyof ExtractParams<Rest>]: string }
    : Path extends `${string}:${infer Param}`
    ? { [K in Param]: string }
    : {}

// 使用示例
type UserProfileRoute = ExtractParams<"/user/:id/profile/:section">
// => { id: string; section: string }

// 目录树类型定义
type FileNode = {
  name: string
  type: 'file'
}

type FolderNode = {
  name: string
  type: 'folder'
  children: TreeNode[]
}

type TreeNode = FileNode | FolderNode

// 链表类型递归
type LinkedList<T> = {
  value: T
  next: LinkedList<T> | null
}

// 函数参数类型提取
type Parameters<T> = 
  T extends (...args: infer P) => any ? P : never

// Promise解包
type UnpackPromise<T> = 
  T extends Promise<infer U> ? U : T

// 数组元素类型提取
type FlattenArray<T> = 
  T extends (infer U)[] ? FlattenArray<U> : T

type Schema = {
  type: 'string' | 'number' | 'boolean' | 'object'
  properties?: Record<string, Schema>
  required?: string[]
}

type Validate<T, S extends Schema> = 
  S['type'] extends 'object' ? {
    [K in keyof T]: 
      K extends keyof S['properties'] 
        ? Validate<T[K], S['properties'][K]> 
        : never
  } & (S['required'] extends undefined ? {} : 
      { [P in S['required'][number]]: unknown })
  : T extends PrimitiveType<S['type']> ? T : never

type PrimitiveType<T> = 
  T extends 'string' ? string :
  T extends 'number' ? number :
  T extends 'boolean' ? boolean : never

// 使用示例
const userSchema: Schema = {
  type: 'object',
  properties: {
    name: { type: 'string' },
    age: { type: 'number' }
  },
  required: ['name']
}

type ValidUser = Validate<{
  name: "Alice",
  age: 30
}, typeof userSchema> // ✅ 验证通过

graph TD
  A[输入JSON数据] --> B{Schema类型校验}
  B -->|对象类型| C[校验属性存在性]
  B -->|基础类型| D[校验类型匹配]
  C --> E[递归校验子属性]
  E --> F{是否所有属性通过}
  D --> G{类型是否匹配}
  F -->|是| H[返回验证通过类型]
  G -->|是| H
  F -->|否| I[返回never类型]
  G -->|否| I

// 分布式条件类型
type ToArray<T> = T extends any ? T[] : never
type StrOrNumArray = ToArray<string | number> // string[] | number[]

// 类型过滤黑科技
type FilterFunction<T> = T extends (...args: any[]) => any ? T : never
type FunctionKeys<T> = {
  [K in keyof T]: FilterFunction<T[K]> extends never ? never : K
}[keyof T]

// 类型缓存技术
type DeepReadonly<T> = {
  readonly [K in keyof T]: T[K] extends object 
    ? T[K] extends Function 
      ? T[K] 
      : DeepReadonly<T[K]> 
    : T[K]
}

// 尾递归优化
type Join<T extends string[], D extends string> =
  T extends [] ? '' :
  T extends [infer F] ? F :
  T extends [infer F, ...infer R] ? `${F & string}${D}${Join<R, D>}` : never

// 定义路由配置类型
type RouteConfig = {
  path: string
  component: React.ComponentType
  guards?: GuardFunction[]
  children?: RouteConfig[]
}

// 自动生成路由参数类型
type ExtractRouteParams<T extends string> =
  T extends `${string}:${infer Param}/${infer Rest}`
    ? { [K in Param | keyof ExtractRouteParams<Rest>]: string }
    : T extends `${string}:${infer Param}`
    ? { [K in Param]: string }
    : {}

// 实现类型安全跳转
declare function navigate<Path extends string>(
  path: Path,
  params: ExtractRouteParams<Path>
): void

// 使用示例
navigate('/user/:id/profile', { id: "123" }) // ✅
navigate('/shop/:category', {}) // ❌ 缺少category参数

graph LR
  A[路由配置] --> B{路径解析}
  B --> C[静态路径匹配]
  B --> D[动态参数提取]
  D --> E[生成参数类型]
  E --> F[类型安全校验]
  F --> G[运行时校验]
  G --> H[路由跳转]
  H --> I{参数合法?}
  I -->|是| J[渲染组件]
  I -->|否| K[显示错误页]

// 二进制位运算实现
type Bit = 0 | 1

type XOR<A extends Bit, B extends Bit> = 
  A extends 0 ? (B extends 0 ? 0 : 1) : (B extends 0 ? 1 : 0)

type AddBinary<A extends Bit[], B extends Bit[]> = {
  // 实现二进制加法器（篇幅限制简写核心逻辑）
  // 完整实现需处理进位、位数对齐等复杂逻辑
}

// 斐波那契数列类型计算
type Fibonacci<N extends number> = 
  N extends 0 ? 0 :
  N extends 1 ? 1 :
  Add<Fibonacci<Sub<N,1>>, Fibonacci<Sub<N,2>>>

// 类型驱动运行时验证
function validate<T>(value: unknown, validator: (v: any) => v is T): T {
  if (validator(value)) return value
  throw new Error('Type validation failed')
}

// 自动生成类型守卫
type Schema = { /* 类型定义 */ }
function createValidator<S extends Schema>(schema: S): (v: any) => v is InferSchema<S> {
  return (v): v is InferSchema<S> => {
    // 根据schema执行运行时验证
    return true // 简化实现
  }
}

graph LR
  A[类型空间] -->|类型推导| B[编译时校验]
  A -->|类型元编程| C[生成运行时验证]
  B --> D[代码提示与错误检测]
  C --> E[数据校验与反序列化]
  D --> F[开发体验提升]
  E --> G[运行时安全性保障]

// 类型安全的状态机实现
type StateMachine<States extends string, Events extends string> = {
  [K in States]: {
    [E in Events]?: (payload: any) => States
  }
}

// 使用示例
type LightStates = 'green' | 'yellow' | 'red'
type LightEvents = 'TIMER' | 'EMERGENCY'

const trafficLight: StateMachine<LightStates, LightEvents> = {
  green: {
    TIMER: () => 'yellow'
  },
  yellow: {
    TIMER: () => 'red',
    EMERGENCY: () => 'red'
  },
  red: {
    TIMER: () => 'green'
  }
}

graph TD
  A[核心类型层] --> B[业务类型层]
  A --> C[基础设施层]
  B --> D[应用逻辑层]
  C -->|提供基础能力| D
  D --> E[单元测试层]
  
  subgraph 核心类型层
    A1[基础工具类型]
    A2[类型运算工具]
  end
  
  subgraph 业务类型层
    B1[领域模型定义]
    B2[业务约束类型]
  end