TypeScript自定义Array.groupBy方法类型推断异常求助

我正在实现一个增强版的Array.groupBy()方法，支持三种分组结果形式：

• 为指定键存储单个对象（替代原生方法的对象数组）
• 提取每个对象的单个属性作为值
• 保留原生的对象数组形式（通过传入'[]'作为第二个参数）

函数执行逻辑正常，但TypeScript类型推断始终不符合预期。

当前类型定义如下：

declare global {
  interface Array<T> {
    /**
     * Groups the elements of an array by a specified field name.
     * 
     * @param fieldName - The field name to group by.
     * @param valueFieldName - Optional. The field name to use as the value in the grouped result.
     *                         If not provided, the entire object will be used as the value.
     *                         If set to '[]', an array of objects with the same field name will be used as the value.
     * @returns An object with the grouped elements.
     */
    groupBy<Key extends keyof T>(
      fieldName: Key,
      valueFieldName?: T[Key]|'[]',
    ): { [key: string]: typeof valueFieldName extends '[]' ? T[] : typeof valueFieldName extends string ? T[Key] : T };
  }
}

以下调用返回结果正确，但类型推断错误：

// 返回 { John: [{ id: 1, name: 'John' }, { id: 3, name: 'John' }], Jane: [{ id: 2, name: 'Jane' }] }
// 类型推断错误：{ [key: string]: { id: number; name: string } }
// 期望类型：{ [key: string]: { id: number; name: string }[] }
const second = [{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }, { id: 3, name: 'John' }]
      .groupBy('name', '[]');
console.log(second)
 
// 返回 { John: 28, Jane: 30 }
// 类型推断错误：{ [key: string]: { id: number; name: string; age: number } }
// 期望类型：{ [key: string]: number }
const third = [{ id: 1, name: 'John', age: 25 }, { id: 2, name: 'Jane', age: 30 }, { id: 3, name: 'John', age: 28 }]
      .groupBy('name', 'age');
console.log(third)

我该如何配置TypeScript以实现正确的类型推断？我认为typeof valueFieldName extends的写法不够理想，但理论上应该可行。或者TypeScript无法进行如此精确的推断？如果是这样，有哪些可行的替代方案？

原类型定义的问题在于：valueFieldName的类型是T[Key] | '[]'的联合类型，TypeScript无法在返回类型中根据传入的具体字面量值做分支推断——typeof valueFieldName在泛型上下文里始终是联合类型，无法收缩到具体值。

要实现精确类型推断，需要把valueFieldName单独设为泛型参数，让TypeScript捕获它的具体字面量类型：

declare global {
  interface Array<T> {
    /**
     * Groups the elements of an array by a specified field name.
     * 
     * @param fieldName - The field name to group by.
     * @param valueFieldName - Optional. The field name to use as the value in the grouped result.
     *                         If not provided, the entire object will be used as the value.
     *                         If set to '[]', an array of objects with the same field name will be used as the value.
     * @returns An object with the grouped elements.
     */
    groupBy<Key extends keyof T, ValueField extends keyof T | '[]' | undefined = undefined>(
      fieldName: Key,
      valueFieldName?: ValueField,
    ): ValueField extends '[]' 
      ? { [key: string]: T[] } 
      : ValueField extends keyof T
        ? { [key: string]: T[ValueField] }
        : { [key: string]: T };
  }
}

修改说明： #

1. 新增ValueField泛型参数，明确约束为keyof T | '[]' | undefined，默认值设为undefined对应不传第二个参数的场景
2. 返回类型通过三层条件分支精确匹配：
   • 若ValueField是'[]'，返回值为对象数组类型
   • 若ValueField是T的属性键，返回值为该键对应的属性类型
   • 否则（不传第二个参数），返回值为原对象类型

验证效果： #

现在重新运行之前的调用，类型推断会完全符合预期：

• second的类型将正确推断为{ [key: string]: { id: number; name: string }[] }
• third的类型将正确推断为{ [key: string]: number }

这种方式利用了TypeScript泛型条件类型对具体字面量类型的匹配能力，相比原写法能更精准地捕获传入参数的类型信息，生成正确的返回类型。

内容的提问来源于stack exchange，提问作者Bruno Pêrel