TypeScript中实现对象数组的级联多属性排序

本文详细介绍了在typescript中对对象数组进行级联多属性排序的通用方法。首先，我们探讨了如何通过指定属性键的优先级顺序进行基础排序；接着，进一步展示了如何集成自定义比较器以处理特定类型或复杂逻辑的排序需求，确保排序过程的类型安全和灵活性。

理解级联排序需求

在处理复杂数据结构时，我们经常需要根据多个条件对数据进行排序。级联排序（Cascading Sort）指的是当主要排序属性的值相同时，才依据次要排序属性进行比较，以此类推，直到找到差异或所有属性都比较完毕。例如，我们可能需要先按状态排序，如果状态相同，则按日期排序。这种需求在TypeScript中实现时，需要兼顾类型安全和代码的通用性。

基于属性键的通用级联排序

最直接的级联排序方式是指定一个属性键的优先级列表。TypeScript的类型系统允许我们通过 keyof T 来安全地引用对象的属性名，从而构建一个通用的排序函数。

核心思路

该方法的核心是利用 Array.prototype.sort() 方法，并在其比较函数中迭代提供的属性键列表。对于每一对被比较的对象 item1 和 item2，我们依次检查每个属性。如果某个属性的值不相等，则直接返回该属性的比较结果（-1 或 1）；如果所有属性的值都相等，则认为这两个对象是相等的，返回 0。

示例代码

interface Item {
a: string;
b: number;
c: Date;
}
/**
* 对对象数组进行级联多属性排序
* @param items 要排序的对象数组
* @param keys 排序属性的优先级列表
*/
function sortByKeys<T>(items: T[], keys: (keyof T)[]): void {
items.sort((item1, item2) => {
for (const key of keys) {
const v1 = item1[key];
const v2 = item2[key];
// 默认比较逻辑：v1 小于 v2 返回 -1，v1 大于 v2 返回 1，相等则继续下一个键
if (v1 < v2) return -1;
if (v2 < v1) return 1;
}
// 所有指定键的值都相等
return 0;
});
}
// 示例数据
const items: Item[] = [
{ a: 'aa', b: 1, c: new Date('2023-01-03T10:00:00Z') },
{ a: 'a', b: 2, c: new Date('2023-01-01T10:00:00Z') },
{ a: 'a', b: 1, c: new Date('2023-01-02T10:00:00Z') },
{ a: 'b', b: 1, c: new Date('2023-01-01T10:00:00Z') },
];
console.log('原始数据:', JSON.parse(JSON.stringify(items)));
// 按照 'b' 属性升序，如果 'b' 相同则按 'a' 属性升序排序
sortByKeys(items, ['b', 'a']);
console.log('按b(升), a(升)排序后:', items);
/* 预期输出（日期部分可能因格式化不同而略有差异，但顺序一致）:
[
{ a: 'a', b: 1, c: Date('2023-01-02T10:00:00Z') },
{ a: 'aa', b: 1, c: Date('2023-01-03T10:00:00Z') },
{ a: 'b', b: 1, c: Date('2023-01-01T10:00:00Z') },
{ a: 'a', b: 2, c: Date('2023-01-01T10:00:00Z') }
]
*/

注意事项

• 此方法适用于属性值可以直接使用 < 和 > 运算符进行比较的类型（如 string, number, Date）。
• 排序是原地进行的，会修改原始数组。如果需要保留原始数组，请先创建数组的副本（例如 […items].sort(…)）。

实现自定义比较逻辑的级联排序

在某些情况下，简单的 < 和 > 比较可能不足以满足需求。例如，日期可能需要特定的降序比较逻辑，或者某些自定义对象需要基于其内部结构的比较。为了应对这些场景，我们可以扩展 sortByKeys 函数，使其能够接受针对特定属性的自定义比较器。

腾讯智影-AI数字人

基于AI数字人能力，实现7*24小时AI数字人直播带货，低成本实现直播业务快速增增，全天智能在线直播

73

查看详情

定义自定义比较器类型

首先，我们需要定义一个通用的自定义比较器类型。它接受两个相同类型的值，并返回一个表示它们相对顺序的数字（-1 表示第一个值小于第二个，0 表示相等，1 表示第一个值大于第二个）。

type CustomSorter<T> = (value1: T, value2: T) => -1 | 0 | 1;

增强型 sortByKeys 函数

新的 sortByKeys 函数将额外接受一个 customSorters 对象，该对象将属性键映射到对应的 CustomSorter。

interface Item {
a: string;
b: number;
c: Date;
}
/**
* 对对象数组进行级联多属性排序，支持自定义比较器
* @param items 要排序的对象数组
* @param keys 排序属性的优先级列表
* @param customSorters 可选的自定义比较器对象，键为属性名，值为该属性的比较函数
*/
function sortByKeys<T>(
items: T[],
keys: (keyof T)[],
customSorters: Partial<{ [key in (keyof T)]: CustomSorter<T[key]>}> = {}
): void {
items.sort((item1, item2) => {
for (const key of keys) {
const v1 = item1[key];
const v2 = item2[key];
const customSorter = customSorters[key]; // 获取当前属性的自定义比较器
if (customSorter) {
// 如果存在自定义比较器，则使用它
const result = customSorter(v1, v2);
if (result !== 0) return result; // 如果不相等，返回比较结果
} else {
// 否则使用默认比较逻辑
if (v1 < v2) return -1;
if (v2 < v1) return 1;
}
}
// 所有指定键的值都相等
return 0;
});
}
// 辅助函数，生成随机日期
const randomDate = () => new Date(Date.now() + Math.floor(Math.random() * 10000000));
// 示例数据
const itemsWithDates: Item[] = [
{ a: 'aa', b: 1, c: randomDate() },
{ a: 'a', b: 2, c: randomDate() },
{ a: 'a', b: 1, c: randomDate() },
{ a: 'b', b: 1, c: randomDate() },
];
console.log('\n原始带日期数据:', JSON.parse(JSON.stringify(itemsWithDates)));
// 按照 'c' 属性（日期）降序排序，并提供自定义日期比较器
sortByKeys(itemsWithDates, ['c'], {
'c': (date1, date2) => {
// 日期降序排序：date1 晚于 date2 则 date1 排在前面（-1）
if (date1 > date2) return -1;
if (date2 > date1) return 1;
return 0;
},
});
console.log('按c(日期降序)排序后:', itemsWithDates);
// 示例：多属性级联排序，其中一个属性使用自定义比较器
const complexItems: Item[] = [
{ a: 'apple', b: 5, c: new Date('2023-01-05T10:00:00Z') },
{ a: 'banana', b: 2, c: new Date('2023-01-01T10:00:00Z') },
{ a: 'apple', b: 2, c: new Date('2023-01-03T10:00:00Z') },
{ a: 'banana', b: 5, c: new Date('2023-01-02T10:00:00Z') },
{ a: 'apple', b: 5, c: new Date('2023-01-01T10:00:00Z') },
];
console.log('\n原始复杂数据:', JSON.parse(JSON.stringify(complexItems)));
// 优先级：b (升序) -> a (升序) -> c (降序)
sortByKeys(complexItems, ['b', 'a', 'c'], {
'c': (date1, date2) => {
if (date1 > date2) return -1;
if (date2 > date1) return 1;
return 0;
},
});
console.log('按b(升), a(升), c(降)排序后:', complexItems);

类型解释

• customSorters: Partial<{ [key in (keyof T)]: CustomSorter<T[key]>}> = {}：
  • keyof T：获取类型 T 的所有属性名组成的联合类型。
  • [key in (keyof T)]：这是一个映射类型，它遍历 T 的所有属性键。
  • CustomSorter<T[key]>：对于每个属性键 key，其值类型是 T[key]，所以对应的比较器类型是 CustomSorter<T[key]>。这确保了为特定属性提供的比较器只能处理该属性类型的值，提供了强大的类型安全。
  • { … }：创建了一个