如何在JavaScript中根据多个属性对数组对象进行分组

本文将深入探讨如何在JavaScript中对包含对象的数组进行分组，特别是当需要根据多个属性（而非单个属性）进行分组时。我们将从单属性分组的基础方法入手，逐步展示如何优化groupBy函数，使其能够接受一个属性键数组，并通过构建复合键来实现多属性分组。文章将提供详细的代码示例和注意事项，帮助开发者高效地管理和组织数据。

理解数组对象分组的基础

在处理数据时，经常需要根据对象的某个特定属性将数组中的对象进行分类。例如，假设我们有一个用户列表，每个用户都有姓名、姓氏和性别等信息：

[
  {
    "name": "john",
    "lastName": "doe",
    "gender": "male"
  },
  {
    "name": "jane",
    "lastName": "doe",
    "gender": "female"
  },
  {
    "name": "peter",
    "lastName": "dickons",
    "gender": "male"
  },
  {
    "name": "eva",
    "lastName": "dickons",
    "gender": "female"
  }
]

如果仅需根据lastName（姓氏）对用户进行分组，可以利用JavaScript的reduce方法实现一个通用的groupByObjectKey函数：

const groupByObjectKey = (users, key) => {
  return users.reduce((accumulator, currentUser) => {
    // 如果当前键不存在，则初始化为空数组
    (accumulator[currentUser[key]] = accumulator[currentUser[key]] || []).push(currentUser);
    return accumulator;
  }, {});
};

let users = [
  { "name": "john", "lastName": "doe", "gender": "male" },
  { "name": "jane", "lastName": "doe", "gender": "female" },
  { "name": "peter", "lastName": "dickons", "gender": "male" },
  { "name": "eva", "lastName": "dickons", "gender": "female" },
];

const usersGroupedByLastName = groupByObjectKey(users, "lastName");
console.log(usersGroupedByLastName);
/*
输出示例:
{
  "doe": [
    { "name": "john", "lastName": "doe", "gender": "male" },
    { "name": "jane", "lastName": "doe", "gender": "female" }
  ],
  "dickons": [
    { "name": "peter", "lastName": "dickons", "gender": "male" },
    { "name": "eva", "lastName": "dickons", "gender": "female" }
  ]
}
*/

这个函数通过reduce迭代数组，并使用指定key的值作为新对象的键，将匹配的对象推入对应的数组中。

立即学习“Java免费学习笔记（深入）”；

扩展至多属性分组

然而，实际应用中往往需要更复杂的分组逻辑，例如，我们可能需要根据lastName和gender（性别）两个属性来对用户进行分组。简单地传入一个属性名数组并不能直接实现这一目标，因为原函数期望的是一个字符串作为键。

为了实现多属性分组，我们需要修改groupBy函数，使其能够接受一个属性键数组。核心思路是：对于每个对象，根据所有指定的属性键生成一个复合键。这个复合键将唯一标识一组具有相同指定属性值的对象。

TTSMaker

TTSMaker是一个免费的文本转语音工具，提供语音生成服务，支持多种语言。

下载

/**
 * 根据一个或多个属性对数组中的对象进行分组。
 * @param {Array<Object>} collection 要分组的数组。
 * @param {string | Array<string>} keys 用于分组的一个或多个属性键。
 * @param {string} [separator='-'] 用于连接多个属性值以形成复合键的分隔符。
 * @returns {Object<string, Array<Object>>} 分组后的对象。
 */
const groupByObjectKeys = (collection, keys, separator = '-') => {
  // 确保keys是一个数组，即使传入的是单个字符串
  const actualKeys = Array.isArray(keys) ? keys : [keys];

  return collection.reduce((accumulator, currentItem) => {
    // 根据所有指定的键获取对应的值，并用分隔符连接成一个复合键
    const compositeKey = actualKeys.map(key => currentItem[key]).join(separator);

    // 如果复合键不存在，则初始化为空数组
    (accumulator[compositeKey] = accumulator[compositeKey] || []).push(currentItem);

    return accumulator;
  }, {});
};

// 示例数据
let users = [
  { "name": "john", "lastName": "doe", "gender": "male" },
  { "name": "jane", "lastName": "doe", "gender": "female" },
  { "name": "peter", "lastName": "dickons", "gender": "male" },
  { "name": "eva", "lastName": "dickons", "gender": "female" },
  { "name": "mike", "lastName": "doe", "gender": "male" } // 添加一个新用户以更好地展示分组
];

// 根据姓氏和性别进行分组
const usersGroupedByLastNameAndGender = groupByObjectKeys(
    users,
    ["lastName", "gender"]
);

console.log(usersGroupedByLastNameAndGender);
/*
输出示例:
{
  "doe-male": [
    { "name": "john", "lastName": "doe", "gender": "male" },
    { "name": "mike", "lastName": "doe", "gender": "male" }
  ],
  "doe-female": [
    { "name": "jane", "lastName": "doe", "gender": "female" }
  ],
  "dickons-male": [
    { "name": "peter", "lastName": "dickons", "gender": "male" }
  ],
  "dickons-female": [
    { "name": "eva", "lastName": "dickons", "gender": "female" }
  ]
}
*/

// 也可以用于单个属性分组，兼容旧用法
const usersGroupedBySingleKey = groupByObjectKeys(users, "lastName");
console.log(usersGroupedBySingleKey);
/*
输出示例:
{
  "doe": [
    { "name": "john", "lastName": "doe", "gender": "male" },
    { "name": "jane", "lastName": "doe", "gender": "female" },
    { "name": "mike", "lastName": "doe", "gender": "male" }
  ],
  "dickons": [
    { "name": "peter", "lastName": "dickons", "gender": "male" },
    { "name": "eva", "lastName": "dickons", "gender": "female" }
  ]
}
*/

在这个groupByObjectKeys函数中：

1. 它现在接受一个keys参数，可以是单个字符串（兼容旧用法）或一个字符串数组。
2. actualKeys变量确保keys始终被视为一个数组，简化后续处理。
3. actualKeys.map(key => currentItem[key]).join(separator)是关键步骤。它遍历所有指定的键，从currentItem中提取对应的值，然后使用一个指定的分隔符（默认为连字符-）将这些值连接成一个字符串。这个字符串就是我们的复合键。
4. 后续逻辑与单属性分组相同，使用这个复合键作为accumulator的属性名。

注意事项

• 分隔符的选择： 选择一个在你的数据中不会自然出现的字符作为分隔符至关重要。例如，如果你的属性值本身可能包含连字符，那么选择其他分隔符（如_或::）会更安全，以避免键冲突。

• 键的顺序： 传入keys数组的顺序会影响复合键的生成，进而影响分组结果。例如，["lastName", "gender"]会生成"doe-male"这样的键，而["gender", "lastName"]会生成"male-doe"，但两者表示的是同一组逻辑。请确保你的应用程序中对键的顺序有一致的理解。

• 性能考量： 对于非常大的数据集和大量的分组键，map和join操作可能会带来轻微的性能开销。然而，对于大多数前端应用或中等规模的数据集，这种开销通常可以忽略不计。

• 类型安全（TypeScript）： 如果在TypeScript环境中使用，可以为函数参数和返回值添加更严格的类型定义，例如：

  interface User {
    name: string;
    lastName: string;
    gender: string;
  }
  
  const groupByObjectKeysTyped = <T extends Record<string, any>>(
    collection: T[],
    keys: keyof T | Array<keyof T>,
    separator: string = '-'
  ): Record<string, T[]> => {
    const actualKeys = Array.isArray(keys) ? keys : [keys];
  
    return collection.reduce((accumulator, currentItem) => {
      const compositeKey = actualKeys.map(key => String(currentItem[key])).join(separator); // 确保转换为字符串
  
      (accumulator[compositeKey] = accumulator[compositeKey] || []).push(currentItem);
      return accumulator;
    }, {} as Record<string, T[]>);
  };

总结

通过对groupBy函数的简单改造，使其能够处理一个属性键数组并生成复合键，我们便能轻松实现根据多个属性对数组对象进行分组的需求。这种方法提高了代码的灵活性和复用性，使得数据组织和管理变得更加高效。在实际开发中，根据具体场景选择合适的分隔符，并注意键的顺序，是确保分组逻辑正确性的关键。