TypeScript方法链：如何返回部分实例限制后续方法调用

需求背景 #

原本的类链式调用返回this，可无限制调用所有方法：

class MyClass {
  methodA(): this {
    return this
  }
  methodB(): this {
    return this
  }
}

new MyClass()
  .methodA()
  .methodB()

现在需要实现：调用methodB后，后续链式调用中无法再调用methodA，即methodB的返回类型需排除methodA。

你的尝试分析 #

1. 返回仅包含methodB的对象

methodB(): Omit<this, "methodA"> {
  return {
    methodB: this.methodB
  } 
}

TypeScript不报错，但该写法会丢失类的其他属性和方法，不符合“仅排除单个方法”的需求。

2. 直接返回this

methodB(): Omit<this, "methodA"> {
  return this
}

TypeScript不报错是因为this的类型是MyClass，而Omit<this, "methodA">是它的子集，类型上兼容。这种写法能满足编译时限制：后续调用methodA会触发编译错误，但运行时methodA依然存在。如果只需要类型层面的约束，这是最简单的方案。

3. 解构this排除methodA

methodB(): Omit<this, "methodA"> {
  const { methodA, ...instance } = this
  return instance
}

ESLint报错是因为类的方法挂载在原型链上，解构实例只能拿到自身的属性，原型上的方法无法被解构出来，最终instance会是空对象，无法正常使用其他方法。

正确实现方案 #

方案1：仅编译时限制（最简单）

直接返回this，依赖TypeScript的类型系统约束：

class MyClass {
  methodA(): this {
    return this
  }
  methodB(): Omit<this, "methodA"> {
    return this
  }
}

new MyClass()
  .methodA()
  .methodB()
  .methodB()
  // .methodA() // 编译报错，符合需求

这种方式不需要修改运行时逻辑，仅通过类型约束达到目的，适合只需要编译时检查的场景。

方案2：运行时+编译时双重限制

如果需要运行时也禁止调用methodA，可以通过Proxy拦截方法调用：

class MyClass {
  methodA(): this {
    console.log('call methodA')
    return this
  }
  methodB(): Omit<this, "methodA"> {
    return new Proxy(this, {
      get(target, prop) {
        if (prop === 'methodA') {
          throw new Error('methodA is not available after calling methodB')
        }
        return Reflect.get(target, prop)
      }
    }) as Omit<this, "methodA">
  }
}

const instance = new MyClass()
instance.methodB().methodA() // 运行时抛出错误，编译时也会报错

方案3：用接口拆分状态（更清晰的类型约束）

通过定义不同的接口区分“可调用methodA”和“不可调用methodA”的状态：

interface WithoutMethodA {
  methodB(): WithoutMethodA;
}

interface WithMethodA extends WithoutMethodA {
  methodA(): WithMethodA;
}

class MyClass implements WithMethodA {
  methodA(): WithMethodA {
    console.log('call methodA')
    return this
  }
  methodB(): WithoutMethodA {
    console.log('call methodB')
    return this
  }
}

new MyClass()
  .methodA()
  .methodB()
  // .methodA() // 编译报错，符合需求

这种方式类型定义更清晰，可读性更强，适合复杂的链式调用场景。

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