JS对象数组按指定属性升序或降序排序

作者:半夏时间:2026-11-21 12:19:39浏览:275

详细讲解在 JavaScript 中如何对对象数组按指定属性进行升序或降序排序,涵盖数值属性排序、字符串与中文拼音排序、通用高阶排序函数封装、空值处理以及不可变排序的最佳实践。

JavaScript 核心指南 阅读时长:约 8 分钟 标准支持:ECMAScript 2015+ / ES2023

在日常前端业务开发中,表格列表与数据卡片的按列排序是高频需求。本文从基础机制、数值与字符串分流、高阶通用函数封装到不可变排序完整梳理解决方案。

JS对象数组按指定属性升序或降序排序
缩略图:JavaScript 对象数组按指定属性升序与降序排序核心概念与重排过程

假设你正在开发一个电商后台管理系统,接口返回了一个包含商品信息的对象数组,每个对象包含 id、name、price 和 sales 等字段。当运营人员在表格表头点击“价格”进行升序查看,或者点击“销量”进行降序筛选时,前端往往需要在本地直接完成这批对象数据的重新排布。

在 JavaScript 中,对对象数组执行排序的核心是调用数组的原生方法 Array.prototype.sort()(或 ES2023 推出的不可变方法 Array.prototype.toSorted()),并传入一个自定义的比较器函数 compareFunction(a, b)。针对数值类型的属性,升序使用 a[key] - b[key],降序使用 b[key] - a[key];针对字符串或中文属性,则通过 String.prototype.localeCompare 进行比较。

一、核心原理:比较器函数(compareFunction)的工作机制

许多初学者直接对对象数组调用 arr.sort(),会发现数组顺序完全没有改变,或者排序结果乱成一团。这是因为默认情况下,sort() 会将数组中的元素隐式转换为字符串 [object Object] 再进行 ASCII 字典序比对。

要让 JavaScript 理解如何比较两个复杂的对象,必须显式传入比较器函数 arr.sort((a, b) => number)。排序算法在内部遍历数组时,会把相邻或待对比的两个对象分别作为参数 a 和 b 传入,并根据返回值的数值正负来决策它们的先后顺序:

  • 返回值小于 0(负数):表示元素 a 应当排在 b 的前面(即 a 的索引更小)。
  • 返回值等于 0:表示两者的排序权重一致,保持相对位置不变(自 ECMAScript 2019 起规范严格要求使用稳定排序算法)。
  • 返回值大于 0(正数):表示元素 b 应当排在 a 的前面(即 b 被移到较前索引)。
JS对象数组按指定属性升序或降序排序
图 1:Array.prototype.sort 比较函数 compareFunction(a, b) 判定逻辑与排列行为

只要掌握了这个规则,升序与降序的推导就十分直观:如果想要属性值较小的对象排在前面(升序),那么当 a[key] < b[key] 时,比较函数应当返回负数,因此直接采用 a[key] - b[key] 即可满足要求。

二、基础实战:数值属性的升序与降序排序

对于价格、库存、年龄、时间戳等数值型属性,可以直接利用减法运算返回正负值。下面以一组商品列表为例进行具体操作。

const products = [
  { id: 101, name: '机械键盘', price: 299, sales: 1200 },
  { id: 102, name: '无线鼠标', price: 99,  sales: 3500 },
  { id: 103, name: '4K显示器', price: 1599, sales: 420 },
  { id: 104, name: '人体工学椅', price: 799, sales: 890 }
];

// 1. 按 price 升序排序 (从低到高: a - b)
const ascByPrice = [...products].sort((a, b) => a.price - b.price);

// 2. 按 price 降序排序 (从高到低: b - a)
const descByPrice = [...products].sort((a, b) => b.price - a.price);

// 3. 按销量 sales 降序排序
const descBySales = [...products].sort((a, b) => b.sales - a.sales);

执行 ascByPrice 后,输出对象的 price 属性依次为 99、299、799、1599;而 descByPrice 的 price 属性则依次为 1599、799、299、99。

注意:不要省略展开运算符 [...]

代码中使用 [...products].sort(...) 而不是直接写 products.sort(...)。这是因为原生 sort() 是“原地修改”方法,会直接破坏并改变原数组。在需要保留原数据或在响应式前端框架中,务必先创建副本。

三、文本处理:字符串属性与中文拼音排序

当需要对用户的姓名、商品品名或分类等文本属性进行排序时,很多开发者容易照搬减法写法,例如写出 (a, b) => a.name - b.name。在 JavaScript 中,非数字字符串相减会直接计算出 NaN,导致比较器失效,排序结果不可预期。

对于字符串类型的属性,标准解决方案是使用 String.prototype.localeCompare() 方法。该方法会根据指定的语言区域规则比较两个字符串,并标准返回 -1、0 或 1:

JS对象数组按指定属性升序或降序排序
图 2:针对对象不同属性类型的判定与排序分流决策流程
const staffList = [
  { id: 1, name: '张三', dept: '技术部' },
  { id: 2, name: '李四', dept: '市场部' },
  { id: 3, name: '王五', dept: '财务部' },
  { id: 4, name: '陈六', dept: '运营部' }
];

// 1. 按姓名中文拼音升序排序
const sortedByNameAsc = [...staffList].sort((a, b) => {
  return a.name.localeCompare(b.name, 'zh-CN');
});

// 2. 按姓名中文拼音降序排序 (反转比较对象即可)
const sortedByNameDesc = [...staffList].sort((a, b) => {
  return b.name.localeCompare(a.name, 'zh-CN');
});

传入第二个参数 'zh-CN' 至关重要。如果不传参数,浏览器会使用当前系统的默认语言环境;而显式指定 'zh-CN' 则能确保中文字符严格按照汉语拼音首字母顺序(A-Z)精准排布,例如“陈(C) -> 李(L) -> 王(W) -> 张(Z)”。

四、进阶抽象:封装可复用的通用动态排序函数

在实际项目工程中,业务组件往往需要支持用户自由点击任意表头进行动态升序或降序切换。如果每次都手写一次内联比较器,代码会非常臃肿且不易维护。

我们可以封装一个通用的高阶排序工具函数 sortByProperty,自动识别数值与字符串,并支持任意字段名与排序方向:

JS对象数组按指定属性升序或降序排序
图 3:通用对象数组动态排序函数的架构与处理流水线
/**
 * 对对象数组按指定属性进行升序或降序排序
 * @param {Array<Object>} list - 需要排序的目标对象数组
 * @param {string} propKey - 作为排序依据的对象属性键名
 * @param {'asc' | 'desc'} order - 排序方向:'asc' 升序,'desc' 降序,默认为 'asc'
 * @returns {Array<Object>} 排序后的新数组副本(不改变原数组)
 */
function sortByProperty(list, propKey, order = 'asc') {
  if (!Array.isArray(list)) return [];
  const factor = order === 'desc' ? -1 : 1;

  // 创建浅拷贝以保障纯函数特性
  return [...list].sort((itemA, itemB) => {
    const valA = itemA[propKey];
    const valB = itemB[propKey];

    // 1. 空值防守:null 或 undefined 始终推到数组末尾
    if (valA == null && valB == null) return 0;
    if (valA == null) return 1;
    if (valB == null) return -1;

    // 2. 数值类型排序
    if (typeof valA === 'number' && typeof valB === 'number') {
      return (valA - valB) * factor;
    }

    // 3. 字符串与其它类型:使用 localeCompare 本地化比较
    return String(valA).localeCompare(String(valB), 'zh-CN', { numeric: true }) * factor;
  });
}

使用该通用函数非常简洁,例如:

// 按价格降序
const res1 = sortByProperty(products, 'price', 'desc');

// 按名称升序
const res2 = sortByProperty(products, 'name', 'asc');

注意到配置项中加入了 { numeric: true },这可以让类似 "file2.txt" 和 "file10.txt" 的自然语言字符串正确按自然数字顺序排序,避免 "file10" 排在 "file2" 前面的常见缺陷。

五、边界场景与健壮性处理

在真实商业项目中,接口返回的数据往往并非完美规整,必须妥善处理以下两个关键边界场景:

1. 空值(null 与 undefined)的处理策略

若数组中部分对象的排序属性为 null、undefined 甚至缺失该键,如果直接使用 a.name.localeCompare 会触发 TypeError: Cannot read properties of undefined 导致程序崩溃;如果参与减法也会产生 NaN。通常的业务设计规范是将空值统一置于末尾(沉底),避免干扰有效数据的对比。

2. 多字段组合级联排序

当第一排序维度的属性值相同时,往往需要按照第二维度进一步比对。例如:先按“部门”升序排序;若部门相同,再按“入职时间”升序排序。这可以通过逻辑或操作符 || 极其优雅地实现:

const users = [
  { name: '张三', dept: '研发部', score: 85 },
  { name: '李四', dept: '市场部', score: 92 },
  { name: '王五', dept: '研发部', score: 95 },
  { name: '赵六', dept: '研发部', score: 80 }
];

// 部门升序;部门相同时按得分 score 降序
users.sort((a, b) => {
  const deptDiff = a.dept.localeCompare(b.dept, 'zh-CN');
  if (deptDiff !== 0) return deptDiff; // 部门不同时直接按部门决定
  return b.score - a.score;           // 部门相同时按分数降序
});

六、现代标准:原地修改与不可变排序 toSorted()

在 ECMAScript 2023(ES14)规范中,JavaScript 官方正式引入了 Array.prototype.toSorted() 方法。它与 sort() 的参数和比较算法完全一致,但最大的区别在于:toSorted() 是不可变的(Immutable),它绝不修改源数组,而是返回排好序的新数组。

const list = [{ id: 2 }, { id: 1 }];

// ES2023 标准推荐写法(无需手动展开拷贝)
const sortedList = list.toSorted((a, b) => a.id - b.id);

console.log(list[0].id);       // 输出 2(原数组保持原封不动)
console.log(sortedList[0].id); // 输出 1(新数组已完成升序排列)
JS对象数组按指定属性升序或降序排序
图 4:JavaScript 对象数组排序 4 大核心关键细节与避坑总结

七、核心方法速查对比

场景类别 升序写法 (ASC) 降序写法 (DESC) 关键要点
数值属性 (a, b) => a[key] - b[key] (a, b) => b[key] - a[key] 不可省略比较函数,否则会被当作 ASCII 字符串比对
文本/中文属性 (a, b) => a[key].localeCompare(b[key], 'zh-CN') (a, b) => b[key].localeCompare(a[key], 'zh-CN') 严禁使用减法;传入 'zh-CN' 支持汉字拼音排序
数据不可变 arr.toSorted((a, b) => ...) [...arr].sort((a, b) => ...) 避免 sort() 原地突变原数据引发 UI 状态同步异常
多级级联 diff1 || diff2 diff1 || (b[k2] - a[k2]) 前级比较差值为 0 时自然回退到次级比较器

综上所述,实现 JavaScript 对象数组按指定属性升序或降序排序并不复杂,其核心逻辑在于清晰识别属性的数据类型并应用对应的数学差值或 localeCompare 判定,同时在工程层面做好不可变数据拷贝与空值防御,即可编写出稳定、高效且具备高扩展性的数据排序逻辑。

作者最新文章
相关文章
更多