TypeScript泛型对象中方法与记录类型的关联类型校验问题

问题场景 #

在处理泛型对象时，需要让propositions和replacer的参数类型保持强关联：当propositions是string[]时，replacer的第二个参数必须是string；当propositions是string[][]时，参数必须是string[]。但TypeScript无法自动识别这种关联，反而将类型约束为string & string[]（不存在的交集类型），导致类型校验失败。

最小复现代码 #

// 文档对象的字段类型为string或string[]
type Field = string | string[];
type Doc = Record<string, Field>;

// 定义变更类型：propositions和replacer的参数类型需一致
type ChangeOf<T extends Field> = {
  propositions: T[];
  replacer(doc: Doc, choice: T): Doc;
};
type Change = ChangeOf<string> | ChangeOf<string[]>;

// 生成变更对象的函数，可能返回任意一种Change类型
function computePropositions(): Change {
  return {
    propositions: ["proposition1", "proposition2"],
    replacer: mapReplacer<string>("key"),
  };
}

// 辅助函数：替换文档指定key的值
function mapReplacer<T extends Field>(
  key: string,
): (doc: Doc, choice: T) => Doc {
  return (doc: Doc, choice: T): Doc => Object.assign(doc, { [key]: choice });
}

function run() {
  const oldDoc = { key: "val" };
  const change = computePropositions();
  // 此处类型校验失败：string | string[] 无法赋值给 string & string[]
  const newDoc = change.replacer(oldDoc, change.propositions[0]);
}

错误信息 #

Argument of type 'string | string[]' is not assignable to parameter of type 'string & string[]'.
  Type 'string' is not assignable to type 'string & string[]'.
    Type 'string' is not assignable to type 'string[]'.

解决方案 #

方案1：用泛型函数封装调用逻辑 #

通过泛型函数将change的类型锁定为单一的ChangeOf<T>分支，让TypeScript能跟踪propositions和replacer的类型关联：

// 原类型和函数保持不变
type Field = string | string[];
type Doc = Record<string, Field>;

type ChangeOf<T extends Field> = {
  propositions: T[];
  replacer(doc: Doc, choice: T): Doc;
};
type Change = ChangeOf<string> | ChangeOf<string[]>;

function computePropositions(): Change {
  return {
    propositions: ["proposition1", "proposition2"],
    replacer: mapReplacer<string>("key"),
  };
}

function mapReplacer<T extends Field>(key: string): (doc: Doc, choice: T) => Doc {
  return (doc: Doc, choice: T): Doc => Object.assign(doc, { [key]: choice });
}

// 新增泛型函数：封装变更应用逻辑
function applyChange<T extends Field>(change: ChangeOf<T>, doc: Doc): Doc {
  return change.replacer(doc, change.propositions[0]);
}

function run() {
  const oldDoc = { key: "val" };
  const change = computePropositions();
  const newDoc = applyChange(change, oldDoc); // 类型校验通过
}

方案2：添加类型标签+类型守卫 #

给ChangeOf添加类型区分标签，通过类型守卫明确当前分支的类型，消除联合类型的歧义：

type Field = string | string[];
type Doc = Record<string, Field>;

// 给ChangeOf添加type标签，区分string和string[]分支
type ChangeOf<T extends Field> = {
  type: T extends string ? "string" : "array";
  propositions: T[];
  replacer(doc: Doc, choice: T): Doc;
};
type Change = ChangeOf<string> | ChangeOf<string[]>;

// 类型守卫：判断是否为string类型的变更
function isStringChange(change: Change): change is ChangeOf<string> {
  return change.type === "string";
}

function computePropositions(): Change {
  return {
    type: "string",
    propositions: ["proposition1", "proposition2"],
    replacer: mapReplacer<string>("key"),
  };
}

function mapReplacer<T extends Field>(key: string): (doc: Doc, choice: T) => Doc {
  return (doc: Doc, choice: T): Doc => Object.assign(doc, { [key]: choice });
}

function run() {
  const oldDoc = { key: "val" };
  const change = computePropositions();
  
  if (isStringChange(change)) {
    // 此处类型明确为ChangeOf<string>，校验通过
    const newDoc = change.replacer(oldDoc, change.propositions[0]);
  } else {
    // 处理array类型分支
    const newDoc = change.replacer(oldDoc, change.propositions[0]);
  }
}

方案说明 #

• 方案1利用TypeScript的联合类型分发特性，泛型函数会自动对Change的每个分支进行处理，确保propositions和replacer属于同一个类型实例，无需额外修改原有类型定义。
• 方案2通过类型标签+守卫显式区分联合类型分支，适合需要对不同分支做差异化处理的场景，类型语义更清晰。

内容的提问来源于stack exchange，提问作者Hugues Le Gendre