如何让TypeScript从泛型函数的参数中推断判别联合类型？

我之前也踩过这个坑！TypeScript在处理这种想让两个参数类型自动绑定的泛型场景时，确实容易出现推断卡壳的情况——你当前的写法逻辑上是对的，但TypeScript没办法在函数内部把泛型T的条件分支和filter、nullValue的类型关联起来，最后就把两者的交集判定成了never，导致includes调用报错。

先给你几个能解决问题的方案，都是我实际用过的：

方案一：用函数重载（最直观的调用体验） #

函数重载是TypeScript处理这种参数类型绑定的经典方式，直接明确两种参数组合的对应关系，调用的时候TypeScript会自动匹配：

type FilterValue = 
  | { type: 'number'; values: number[] } 
  | { type: 'guid'; values: string[] };

// 先定义两个重载签名，明确参数的对应关系
function applyFilter(filter: Extract<FilterValue, { type: 'number' }>, nullValue: number): void;
function applyFilter(filter: Extract<FilterValue, { type: 'guid' }>, nullValue: string): void;

// 然后是实现签名，用宽泛的类型接收参数
function applyFilter(filter: FilterValue, nullValue: number | string) {
  // 内部用判别联合的type属性做类型收窄，TypeScript会自动识别对应的values类型
  if (filter.type === 'number') {
    if (filter.values.includes(nullValue as number)) {
      // 处理数字类型的逻辑
    }
  } else {
    if (filter.values.includes(nullValue as string)) {
      // 处理GUID类型的逻辑
    }
  }
}

这种写法的好处是，外部调用的时候完全不需要关心泛型，传入nullValue: 0就只能传number类型的filter，传入GUID格式的字符串就只能传guid类型的filter，非常直观。

方案二：优化泛型逻辑（更符合你想要的“纯泛型”需求） #

如果你坚持要用泛型写法，可以调整泛型的约束逻辑，让TypeScript能明确跟踪两个参数的类型关联。比如把泛型绑定到判别联合的type字段，而不是直接绑定到number/string：

type FilterValue = 
  | { type: 'number'; values: number[] } 
  | { type: 'guid'; values: string[] };

// 定义两个工具类型，根据type字段推导对应的filter和nullValue类型
type FilterForType<T extends FilterValue['type']> = Extract<FilterValue, { type: T }>;
type NullValueForType<T extends FilterValue['type']> = FilterForType<T>['values'][number];

function applyFilter<T extends FilterValue['type']>(
  filter: FilterForType<T>,
  nullValue: NullValueForType<T>
) {
  // 内部通过filter.type自动收窄类型，includes调用完全安全，不需要断言
  if (filter.type === 'number') {
    if (filter.values.includes(nullValue)) {
      // 数字类型逻辑
    }
  } else {
    if (filter.values.includes(nullValue)) {
      // GUID类型逻辑
    }
  }
}

这里泛型T是'number'或'guid'，TypeScript能明确知道：当T是'number'时，nullValue必须是number，filter.values是number[]；当T是'guid'时同理。内部的类型收窄完全自动，不需要额外的类型断言。

方案三：极简泛型写法（最简洁的实现） #

还有一种更简洁的泛型写法，直接把泛型绑定到整个FilterValue类型，然后用索引类型获取对应的nullValue类型：

type FilterValue = 
  | { type: 'number'; values: number[] } 
  | { type: 'guid'; values: string[] };

function applyFilter<F extends FilterValue>(
  filter: F,
  nullValue: F['values'][number]
) {
  // 这里TypeScript会自动推断F的类型，nullValue和filter.values的元素类型完全匹配
  if (filter.values.includes(nullValue)) {
    // 通用逻辑处理
  }
}

这个写法的核心是，泛型F代表传入的具体filter类型，F['values'][number]就是该filter的values数组的元素类型，所以nullValue必须和这个类型完全兼容。调用的时候TypeScript会自动完成类型推断，比如传入number类型的filter，就只能传number类型的nullValue，完全不会有类型错误。

为什么你的原写法会报错？ #

你原来的写法里，用了条件泛型来推导filter的类型，但TypeScript在函数内部没办法“记住”泛型T的条件分支——它只知道filter是Extract<FilterValue, { type: 'number' }> | Extract<FilterValue, { type: 'guid' }>，nullValue是number | string，但没法确定两者的类型是一一对应的，所以把filter.values.includes(nullValue)的参数类型判定成了never（因为number和string的交集是never）。

而上面的几种方案，要么通过重载明确了参数的绑定关系，要么通过泛型把两个参数的类型直接关联起来，让TypeScript能清晰跟踪到类型的对应性，自然就解决了推断问题。

内容来源于stack exchange