JavaScript Array.prototype.sort() 方法详解
Array.prototype.sort() 是JavaScript中用于对数组元素进行原地排序的内置方法。当不传入任何参数时，它会将数组元素转换为字符串，然后按照UTF-16码元值升序排序。然而，对于数字或自定义对象排序，我们通常需要提供一个比较函数（compareFunction）。
比较函数接收两个参数 a 和 b，代表数组中将被比较的两个元素。它的返回值决定了 a 和 b 在排序后的相对位置：
- 如果返回一个负值，a 会排在 b 之前。
- 如果返回一个正值，a 会排在 b 之后。
- 如果返回零，a 和 b 的相对位置保持不变（或者说，它们被认为是相等的）。
propSort 函数的工作原理
propSort 函数是一个实用工具，旨在简化对包含对象的数组进行排序，特别是当需要根据这些对象内部的某个特定数字属性进行排序时。
/**
* sort array by numeric by numeric property values
* of object entries. null entries are treated as 0.
* array entries must be objects.
* @param {object[]} arr - 要排序的对象数组。
* @param {string} prop - 用于排序的数字属性名（字符串）。
*/
export const propSort = (arr, prop) => {
arr.sort((a, b) => {
return (a[prop] || 0) - (b[prop] || 0);
});
};该函数的核心在于其传递给 arr.sort() 的比较函数：(a, b) => { return (a[prop] || 0) - (b[prop] || 0); }。
立即学习“Java免费学习笔记（深入）”；
参数 a 和 b: 在 sort() 方法执行期间，它会迭代数组中的元素，并将每次比较的两个元素作为 a 和 b 传递给这个回调函数。在这里，a 和 b 就是 arr 数组中的两个对象元素。
动态属性访问 a[prop]: prop 参数是一个字符串，代表了对象中我们希望用来排序的属性名称。在JavaScript中，我们可以使用方括号表示法 object[propertyNameString] 来通过字符串动态访问对象的属性。因此，a[prop] 和 b[prop] 分别获取了当前比较的两个对象 a 和 b 上名为 prop 的属性值。
处理空值或缺失属性 (value || 0): (a[prop] || 0) 是一种常见的JavaScript模式，用于处理属性可能不存在、为 null 或 undefined 的情况。|| 逻辑或运算符会返回第一个真值表达式。如果 a[prop] 的值是 null、undefined、0、false 或空字符串（这些都是“假值”），那么表达式 (a[prop] || 0) 将会返回 0。这意味着，对于那些没有指定 prop 属性或其值为 null/undefined 的对象，在排序时它们的该属性值将被视为 0。这确保了排序逻辑的健壮性，避免了因尝试对 undefined 进行数学运算而导致的错误。
-
数值比较 (valueA - valueB): 对于数字排序，最简洁有效的方法就是直接相减。
- 如果 a[prop] 大于 b[prop]，结果为正值，a 排在 b 之后。
- 如果 a[prop] 小于 b[prop]，结果为负值，a 排在 b 之前。
- 如果 a[prop] 等于 b[prop]，结果为零，相对顺序不变。
示例代码
让我们通过一个具体的例子来演示 propSort 的用法。
const users = [
{ name: 'Alice', age: 30, score: 85 },
{ name: 'Bob', age: 25, score: 92 },
{ name: 'Charlie', age: 35, score: 78 },
{ name: 'David', age: 28, score: null }, // score 为 null
{ name: 'Eve', age: 22 } // 没有 score 属性
];
console.log("原始数组:");
console.log(users);
// 根据 'age' 属性进行排序
propSort(users, 'age');
console.log("\n按 'age' 排序后的数组:");
console.log(users);
/*
[
{ name: 'Eve', age: 22 },
{ name: 'Bob', age: 25, score: 92 },
{ name: 'David', age: 28, score: null },
{ name: 'Alice', age: 30, score: 85 },
{ name: 'Charlie', age: 35, score: 78 }
]
*/
// 根据 'score' 属性进行排序
// 注意：null 和 undefined 的 score 会被视为 0，因此排在最前面
propSort(users, 'score');
console.log("\n按 'score' 排序后的数组 (null/undefined 视为 0):");
console.log(users);
/*
[
{ name: 'David', age: 28, score: null }, // score 视为 0
{ name: 'Eve', age: 22 }, // score 视为 0
{ name: 'Charlie', age: 35, score: 78 },
{ name: 'Alice', age: 30, score: 85 },
{ name: 'Bob', age: 25, score: 92 }
]
*/TypeScript 转换考量
将 propSort 函数从 JavaScript 转换为 TypeScript 可以显著提升代码的类型安全性和可维护性。
- 定义对象类型: 明确数组中对象的结构。
- 泛型约束: 使用泛型 T 来表示数组中对象的类型，并添加约束以确保 prop 属性存在且是数字。
- keyof T: 对于 prop 参数，使用 keyof T 可以限制它只能是 T 类型对象的属性名，进一步增强类型检查。
/**
* 根据对象数组中指定数字属性的值进行排序。
* 缺失或 null 的属性值将被视为 0。
*
* @template T - 数组中对象的类型。
* @param {T[]} arr - 要排序的对象数组。
* @param {keyof T} prop - 用于排序的数字属性名。
*/
export const propSort = >(
arr: T[],
prop: keyof T
): void => {
arr.sort((a, b) => {
// 断言属性值为 number | null | undefined，确保类型安全
const valA = (a[prop] as number | null | undefined) || 0;
const valB = (b[prop] as number | null | undefined) || 0;
return valA - valB;
});
};
// 示例使用 TypeScript
interface User {
name: string;
age: number;
score?: number | null; // score 可能是可选的，或为 null
}
const tsUsers: User[] = [
{ name: 'Alice', age: 30, score: 85 },
{ name: 'Bob', age: 25, score: 92 },
{ name: 'Charlie', age: 35, score: 78 },
{ name: 'David', age: 28, score: null },
{ name: 'Eve', age: 22 } // 没有 score 属性
];
// 类型安全：prop 必须是 User 接口的键
propSort(tsUsers, 'age');
console.log("\nTypeScript 示例 - 按 'age' 排序:");
console.log(tsUsers);
propSort(tsUsers, 'score'); // 允许，因为 score 属性存在
console.log("\nTypeScript 示例 - 按 'score' 排序:");
console.log(tsUsers);
// propSort(tsUsers, 'nonExistentProp'); // 这将导致 TypeScript 编译错误 在 TypeScript 版本中，我们使用了泛型 T 并通过 extends Record
总结
propSort 函数是一个简洁而强大的工具，它封装了 Array.prototype.sort() 的复杂性，提供了一种灵活的方式来根据对象数组中特定数字属性的值进行排序。通过动态属性访问和对缺失/空值的优雅处理，它增强了代码的鲁棒性。在转换为 TypeScript 时，利用泛型和类型约束可以进一步提升函数的类型安全性和可读性，使其成为处理结构化数据排序的理想选择。理解其底层机制，特别是 sort() 比较函数和 || 运算符的用法，对于编写高效且可维护的 JavaScript/TypeScript 代码至关重要。
