如何用TypeScript泛型定义复杂动态作用域树结构？

核心思路 #

将父作用域类型作为单一泛型参数传入，通过递归结构自动捕获完整作用域链，彻底替代大量可选泛型的冗余写法。所有作用域类型都基于一个基础接口构建，该接口仅接受父作用域类型作为泛型参数。

定义基础作用域类型 #

先搭建所有作用域的通用骨架，包含类型标识、父作用域引用和通用声明属性：

type ScopeType = 'module' | 'class' | 'function' | 'condition' | 'loop' | 'fork';

interface BaseScope<Parent extends BaseScope<any> | null = null> {
  type: ScopeType;
  parent: Parent;
  declarations: Record<string, unknown>; // 存储当前作用域的变量/声明
}

具体作用域类型实现 #

基于基础接口，为每种作用域定义专属类型，递归传入父作用域类型以保留链状类型信息：

// 顶层模块作用域，父作用域固定为null
type ModuleScope = BaseScope<null> & {
  type: 'module';
  subModules?: ModuleScope[];
};

// 类作用域，父作用域可为任意类型
type ClassScope<Parent extends BaseScope<any> | null = null> = BaseScope<Parent> & {
  type: 'class';
  methods: FunctionScope<ClassScope<Parent>>[]; // 方法的父作用域是当前类
  nestedClasses: ClassScope<ClassScope<Parent>>[]; // 嵌套类的父作用域是当前类
};

// 函数作用域，支持嵌套函数、条件、循环
type FunctionScope<Parent extends BaseScope<any> | null = null> = BaseScope<Parent> & {
  type: 'function';
  nestedFunctions: FunctionScope<FunctionScope<Parent>>[];
  conditions: ConditionScope<FunctionScope<Parent>>[];
  loops: LoopScope<FunctionScope<Parent>>[];
};

// 条件/循环/分支作用域同理，递归绑定父作用域类型
type ConditionScope<Parent extends BaseScope<any> | null = null> = BaseScope<Parent> & {
  type: 'condition';
  nestedConditions: ConditionScope<ConditionScope<Parent>>[];
  nestedLoops: LoopScope<ConditionScope<Parent>>[];
};

type LoopScope<Parent extends BaseScope<any> | null = null> = BaseScope<Parent> & {
  type: 'loop';
  nestedConditions: ConditionScope<LoopScope<Parent>>[];
  nestedFunctions: FunctionScope<LoopScope<Parent>>[];
};

type ForkScope<Parent extends BaseScope<any> | null = null> = BaseScope<Parent> & {
  type: 'fork';
  branches: (FunctionScope<ForkScope<Parent>> | ConditionScope<ForkScope<Parent>>)[];
};

使用示例 #

定义后可完整捕获多层嵌套的作用域类型链，类型推导会自动识别父作用域的具体类型：

// 模块→类→方法→嵌套函数的完整作用域链
const deepNestedFunc: FunctionScope<FunctionScope<ClassScope<ModuleScope>>> = {
  type: 'function',
  parent: {
    type: 'function',
    parent: {
      type: 'class',
      parent: {
        type: 'module',
        parent: null,
        declarations: {},
      },
      declarations: {},
      methods: [],
      nestedClasses: [],
    },
    declarations: {},
    nestedFunctions: [],
    conditions: [],
    loops: [],
  },
  declarations: {},
  nestedFunctions: [],
  conditions: [],
  loops: [],
};

// 自动推导父作用域类型
const parentClass = deepNestedFunc.parent.parent;
// parentClass 的类型为 ClassScope<ModuleScope>

方案优势 #

• 仅用单一泛型参数传递父作用域类型，避免可选泛型的冗余
• 递归结构自然延伸，完整保留整个作用域树的类型链信息
• 类型推导精准，访问父作用域时能直接获取对应类型

内容的提问来源于stack exchange，提问作者Lance Pollard