TypeScript通用排序模块中SortKey数组的类型定义问题求解

问题根源 #

你遇到的核心问题是：当定义SortKey<T>[]数组时，TypeScript会尝试为整个数组推断一个统一的K类型（即keyof T的联合类型），这就要求每个元素的comparer必须兼容所有T[K]类型的联合，而不是对应单个key的具体类型。比如Person类型中id是number、name是string，TypeScript会要求comparer必须是Comparer<string | number>，但你的numberComparer和stringComparer只兼容单一类型，因此报错。

解决方案 #

通过定义一个包含所有可能SortKey类型的联合类型，让数组元素可以是任意单个key对应的SortKey类型，从而让TypeScript为每个元素单独推断正确的类型。

类型定义调整

export type Comparer<T> = (a: T, b: T) => number;

// 保留单个SortKey的泛型定义，K必须是T的具体key
export type SortKey<T, K extends keyof T> = {
    key: K,
    order: 'ascending' | 'descending',
    comparer: Comparer<T[K]>
};

// 生成所有可能SortKey类型的联合
export type SortKeys<T> = { 
    [K in keyof T]: SortKey<T, K> 
}[keyof T];

排序函数实现

将排序函数的sortKeys参数类型改为SortKeys<T>[]，这样数组中的每个元素可以是任意key对应的SortKey，TypeScript会自动校验每个元素的comparer与key的类型匹配：

function sortData<T>(data: T[], sortKeys: SortKeys<T>[]): T[] {
    return [...data].sort((a, b) => {
        // 依次按每个排序键比较，直到找到非0结果
        for (const { key, order, comparer } of sortKeys) {
            const comparisonResult = comparer(a[key], b[key]);
            if (comparisonResult !== 0) {
                return order === 'ascending' ? comparisonResult : -comparisonResult;
            }
        }
        return 0;
    });
}

测试示例

以Person类型为例，现在可以正常混合不同类型的排序键：

type Person = {
    id: number;
    name: string;
    age: number;
};

// 对应不同类型的比较器
const numberComparer: Comparer<number> = (a, b) => a - b;
const stringComparer: Comparer<string> = (a, b) => a.localeCompare(b);

// 数组中的每个元素类型都会被正确推断，不会出现类型不匹配
const sortConfig: SortKeys<Person>[] = [
    { key: 'id', order: 'ascending', comparer: numberComparer },
    { key: 'name', order: 'descending', comparer: stringComparer },
    { key: 'age', order: 'ascending', comparer: numberComparer }
];

// 测试数据
const people: Person[] = [
    { id: 2, name: 'Bob', age: 30 },
    { id: 1, name: 'Alice', age: 25 },
    { id: 3, name: 'Charlie', age: 35 }
];

// 执行排序
const sortedPeople = sortData(people, sortConfig);
console.log(sortedPeople);

原理说明 #

SortKeys<T>通过映射类型遍历T的所有key，为每个key生成对应的SortKey<T, K>类型，然后通过[keyof T]取出所有这些类型的联合。这样数组中的每个元素都可以是任意一个具体key对应的SortKey，TypeScript会为每个元素单独校验key和comparer的类型匹配，避免了联合类型带来的冲突。

内容的提问来源于stack exchange，提问作者José Ramírez