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

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];

      // 如果值不相等，则根据当前属性决定顺序
      if (v1 < v2) return -1;
      if (v2 < v1) return 1;
    }
    // 所有属性都相等，保持原始顺序
    return 0;
  });
}

// 示例用法
const items: Item[] = [
  { a: 'aa', b: 1, c: new Date('2023-01-03') },
  { a: 'a', b: 2, c: new Date('2023-01-01') },
  { a: 'a', b: 1, c: new Date('2023-01-02') },
  { a: 'ab', b: 1, c: new Date('2023-01-04') },
];

console.log('原始数组:', JSON.parse(JSON.stringify(items))); // 深拷贝，避免原始数组被修改影响后续示例

// 示例1: 优先按 'b' 排序，然后按 'a' 排序
sortByKeys(items, ['b', 'a']);
console.log('按 b, a 排序:', items);
/*
输出示例:
[
  { a: 'a', b: 1, c: Date },
  { a: 'aa', b: 1, c: Date },
  { a: 'ab', b: 1, c: Date },
  { a: 'a', b: 2, c: Date }
]
*/

// 示例2: 优先按 'a' 排序，然后按 'b' 排序
const items2: Item[] = [
  { a: 'aa', b: 1, c: new Date('2023-01-03') },
  { a: 'a', b: 2, c: new Date('2023-01-01') },
  { a: 'a', b: 1, c: new Date('2023-01-02') },
  { a: 'ab', b: 1, c: new Date('2023-01-04') },
];
sortByKeys(items2, ['a', 'b']);
console.log('按 a, b 排序:', items2);
/*
输出示例:
[
  { a: 'a', b: 1, c: Date },
  { a: 'a', b: 2, c: Date },
  { a: 'aa', b: 1, c: Date },
  { a: 'ab', b: 1, c: Date }
]
*/

interface Item {
  a: string;
  b: number;
  c: Date;
}

/**
 * 自定义比较器类型，返回 -1 (v1 < v2), 0 (v1 == v2), 或 1 (v1 > v2)。
 */
type CustomSorter<V> = (value1: V, value2: V) => -1 | 0 | 1;

/**
 * 根据指定的属性键序列和可选的自定义比较器对数组进行级联排序。
 * @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 as T[typeof key], v2 as T[typeof key]);
        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() * 1000000));

const itemsWithDates: Item[] = [
  { a: 'aa', b: 1, c: new Date('2023-01-03T10:00:00Z') },
  { a: 'a', b: 2, c: new Date('2023-01-01T12:00:00Z') },
  { a: 'a', b: 1, c: new Date('2023-01-02T14:00:00Z') },
  { a: 'ab', b: 1, c: new Date('2023-01-04T08:00:00Z') },
];

console.log('\n原始带日期数组:', JSON.parse(JSON.stringify(itemsWithDates)));

// 示例3: 优先按 'c' (日期) 排序，使用自定义日期比较器
sortByKeys(itemsWithDates, ['c'], {
  'c': (date1: Date, date2: Date) => {
    if (date1 < date2) return -1;
    if (date2 < date1) return 1;
    return 0;
  },
});
console.log('按 c (自定义日期) 排序:', itemsWithDates);
/*
输出示例:
[
  { a: 'a', b: 2, c: Date('2023-01-01T12:00:00.000Z') },
  { a: 'a', b: 1, c: Date('2023-01-02T14:00:00.000Z') },
  { a: 'aa', b: 1, c: Date('2023-01-03T10:00:00.000Z') },
  { a: 'ab', b: 1, c: Date('2023-01-04T08:00:00.000Z') }
]
*/

// 示例4: 优先按 'a' (字符串，不区分大小写)，然后按 'b' (数字) 排序
const itemsCaseInsensitive: Item[] = [
  { a: 'Apple', b: 2, c: randomDate() },
  { a: 'banana', b: 1, c: randomDate() },
  { a: 'apple', b: 1, c: randomDate() },
  { a: 'Banana', b: 3, c: randomDate() },
];
console.log('\n原始不区分大小写数组:', JSON.parse(JSON.stringify(itemsCaseInsensitive)));

sortByKeys(itemsCaseInsensitive, ['a', 'b'], {
  'a': (str1: string, str2: string) => {
    const s1 = str1.toLowerCase();
    const s2 = str2.toLowerCase();
    if (s1 < s2) return -1;
    if (s2 < s1) return 1;
    return 0;
  },
});
console.log('按 a (不区分大小写), b 排序:', itemsCaseInsensitive);
/*
输出示例:
[
  { a: 'apple', b: 1, c: Date },
  { a: 'Apple', b: 2, c: Date },
  { a: 'banana', b: 1, c: Date },
  { a: 'Banana', b: 3, c: Date }
]
*/