如何在TypeScript中定义带有算术约束的对象类型？

好问题！TypeScript的静态类型系统本身没法直接在类型定义里编写算术约束（比如a % b === 0这种条件），不过咱们可以通过几种办法来实现类似的效果，确保实例符合规则。下面给你拆解几个可行的方案：

方案1：断言函数——运行时检查+类型强化 #

这是最直接的方式：写一个专门的断言函数，接收对象后验证a % b === 0的条件，不满足就抛出错误；同时通过TypeScript的断言语法，让通过检查的对象被TS识别为合法的RestrictedObject类型。

type RestrictedObject = { a: number; b: number };

function assertIsRestrictedObject(obj: unknown): asserts obj is RestrictedObject {
  // 先做基础类型校验
  if (typeof obj !== 'object' || obj === null) {
    throw new Error('输入不是有效的对象');
  }
  const { a, b } = obj as RestrictedObject;
  if (typeof a !== 'number' || typeof b !== 'number') {
    throw new Error('a和b必须都是数字类型');
  }
  // 处理除以零的边界情况
  if (b === 0) {
    throw new Error('b不能为0，否则会触发除以零错误');
  }
  // 核心算术约束检查
  if (a % b !== 0) {
    throw new Error(`不符合约束：a(${a})无法被b(${b})整除`);
  }
}

// 使用示例
const validObj = { a: 6, b: 2 };
assertIsRestrictedObject(validObj); // 校验通过，TS现在认为validObj是RestrictedObject类型

const invalidObj = { a: 7, b: 2 };
assertIsRestrictedObject(invalidObj); // 运行时抛出错误，直接拦截非法实例

优缺点：简单易实现，能覆盖所有数字场景；但检查发生在运行时，编译阶段没法提前发现错误（比如你直接写const invalidObj = {a:7,b:2}，TS不会报错，直到调用断言函数才会触发错误）。

方案2：品牌类型——确保只有合法实例能进入类型系统 #

如果想从根源上避免非法实例被标记为RestrictedObject，可以用「品牌类型」给合法对象打上唯一标记，只有通过特定工厂函数创建的实例才能拥有这个标记。

// 用unique symbol创建一个唯一的品牌标记，外部无法手动复制
declare const RestrictedBrand: unique symbol;

type RestrictedObject = {
  a: number;
  b: number;
  // 品牌标记，用来区分合法/非法实例
  [RestrictedBrand]: true;
};

// 工厂函数：只有通过这个函数创建的对象才是合法的RestrictedObject
function createRestrictedObject(a: number, b: number): RestrictedObject {
  if (b === 0 || a % b !== 0) {
    throw new Error('不符合约束：a必须能被b整除且b不为0');
  }
  return { a, b, [RestrictedBrand]: true } as RestrictedObject;
}

// 使用示例
const validObj = createRestrictedObject(8, 4); // 正确，TS识别为RestrictedObject类型

// 手动创建的对象无法通过类型校验，因为外部无法访问RestrictedBrand
const invalidObj = { a: 7, b: 2, [RestrictedBrand]: true }; // 编译报错！

优缺点：从类型层面杜绝了非法实例混入，编译阶段就能拦截手动创建的非法对象；但需要通过工厂函数创建实例，灵活性稍有降低。

方案3：泛型+字面量类型——编译阶段约束特定场景 #

如果你的b是固定的字面量值（比如只能是1、2、3这类已知值），可以结合泛型和字面量类型，让TS在编译阶段就限制a必须是b的倍数。

不过要注意：TypeScript的类型系统对动态数字运算支持有限，没法自动生成所有倍数，所以这个方案适合场景明确的情况：

// 先定义允许的b值
type ValidB = 1 | 2 | 3 | 4;

// 针对不同的b值，定义对应的合法a类型
type RestrictedObject<B extends ValidB> = {
  b: B;
  a: B extends 1 ? number : 
      B extends 2 ? 2 | 4 | 6 | 8 | 10 : // 列出2的倍数
      B extends 3 ? 3 | 6 | 9 | 12 :
      B extends 4 ? 4 | 8 | 12 | 16 :
      never;
};

// 使用示例
const obj1: RestrictedObject<2> = { b: 2, a: 6 }; // 正确
const obj2: RestrictedObject<2> = { b: 2, a: 7 }; // 编译报错！a必须是2、4、6、8、10中的一个

优缺点：编译阶段就能校验，不需要运行时检查；但只适合b是固定枚举值的场景，无法覆盖动态的b值。

总结 #

TypeScript作为静态类型系统，没法直接在类型定义里写动态算术约束，但我们可以结合：

• 断言函数+品牌类型：兼顾运行时检查和类型安全，适合大多数场景
• 泛型+字面量类型：适合b固定的特定场景

根据你的实际需求选择对应的方案就好啦！

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