如何用TypeScript类型系统实现类似Rust的一次性消费对象？

可以利用TypeScript的类型系统模拟Rust中这种"一次性消费"的行为——虽然TS没有原生的所有权转移机制，但我们可以通过状态标记的联合类型或泛型条件类型，在编译阶段阻止对已消费对象的重复调用。

实现思路核心 #

Rust的consume(self)本质是通过所有权转移让原变量失效；TS里我们可以给对象标记"未消费/已消费"的状态，让类型系统识别状态变化，从而限制方法调用。

方案1：联合类型标记状态 #

通过两个互斥的类型分别表示"活跃"和"已消费"的对象，consume方法返回已消费状态的对象，强制调用者更新变量类型：

// 未消费状态：拥有可调用的consume方法
type ActiveFoo = {
  state: 'active';
  consume: () => [number, ConsumedFoo];
};

// 已消费状态：consume方法设为never，调用会触发编译错误
type ConsumedFoo = {
  state: 'consumed';
  consume: never;
};

type Foo = ActiveFoo | ConsumedFoo;

// 创建未消费的Foo实例
function createFoo(): ActiveFoo {
  return {
    state: 'active',
    consume() {
      console.log('consumed!');
      return [42, { state: 'consumed', consume: undefined as never }];
    }
  };
}

// 使用示例
let foo: Foo = createFoo();
// 第一次调用：正常执行，同时获取返回值和已消费对象
const [val1, consumedFoo] = foo.consume();
// 更新变量为已消费状态
foo = consumedFoo;
// 第二次调用：TypeScript编译报错，因为foo现在是ConsumedFoo类型，consume为never
foo.consume();

方案2：泛型类实现状态约束 #

用泛型类绑定对象状态，通过条件类型限制consume方法的可用性：

class Foo<T extends 'active' | 'consumed'> {
  private readonly state: T;

  constructor(state: T = 'active' as T) {
    this.state = state;
  }

  // 仅当对象处于active状态时，consume方法才返回有效结果；否则返回never
  consume(): T extends 'active' ? [number, Foo<'consumed'>] : never {
    if (this.state !== 'active') {
      throw new Error('对象已被消费，无法重复调用');
    }
    console.log('consumed!');
    return [42, new Foo<'consumed'>('consumed')] as any;
  }
}

// 使用示例
let foo = new Foo<'active'>();
const [val1] = foo.consume();
// 将foo更新为已消费状态的实例
foo = new Foo<'consumed'>('consumed');
// 编译报错：无法调用返回never类型的方法
foo.consume();

注意事项 #

• 这种方式是编译时检查，如果运行时不主动更新变量状态（比如不把已消费对象赋值给原变量），还是能调用方法，但编译阶段会提前报错。
• 相比Rust的所有权系统，TS的模拟方案需要开发者主动配合更新状态，但已经能满足"禁止重复消费"的编译约束需求。

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