JavaScript中根据键值比较两个对象并计算总和的教程

珍惜时间，勤奋学习！今天给大家带来《JavaScript中根据键值比较两个对象并计算总和的教程 》，正文内容主要涉及到等等，如果你正在学习文章，或者是对文章有疑问，欢迎大家关注我！后面我会持续更新相关内容的，希望都能帮到正在学习的大家！

本教程旨在指导开发者如何在JavaScript中，依据一个嵌套对象（`values`）的键值，从另一个对象（`points`）中匹配并计算相应分数的总和。文章提供了多种实现策略，包括使用`reduce`进行迭代聚合，以及通过构建查找表进行高效数据匹配和求和，以满足复杂的数据处理需求。

在前端开发中，我们经常会遇到需要处理结构化数据并进行聚合计算的场景。一个典型的例子是，我们有两个JavaScript对象：一个包含用户选择或状态的嵌套对象，另一个则存储了这些选择对应的分数。我们的目标是根据第一个对象的键值，从第二个对象中查找对应的分数并计算总和。

考虑以下两个JavaScript对象作为示例数据：

const values = {
    Q1: {
        Q1A1: "Yes",
    },
    Q2: {
        Q2A1: "Yes",
    },
    Q3: {
        Q3A2: "No",
    },
};

const points = {
    Q1A1: 41,
    Q1A2: 0,
    Q2A1: 19,
    Q2A2: 0,
    Q3A1: 25,
    Q3A2: 0, // 假设这里是0，如果题目要求Q3A2="No"不计分，则即使这里是5也应忽略
};

我们的目标是根据values对象中嵌套的键（例如Q1A1、Q2A1）以及它们的值（例如"Yes"），从points对象中查找对应的分数并求和。例如，如果Q1A1是"Yes"，则计入points.Q1A1的分数；如果Q3A2是"No"，则不计分。最终结果应为41 + 19 = 60。

接下来，我们将探讨几种实现这一目标的JavaScript方法。

方法一：使用嵌套 reduce 进行直接聚合

这种方法通过两次 reduce 迭代，直接遍历 values 对象的结构，并在满足条件时累加分数。

const values = {
    Q1: { Q1A1: "Yes" },
    Q2: { Q2A1: "Yes" },
    Q3: { Q3A2: "No" },
};

const points = {
    Q1A1: 41,
    Q1A2: 0,
    Q2A1: 19,
    Q2A2: 0,
    Q3A1: 25,
    Q3A2: 5, // 假设这里是5，但由于Q3A2="No"，此值不应被计入
};

const total = Object.values(values) // 获取values对象中所有Q1, Q2, Q3等子对象
  .reduce((acc, cur) => { // 外层reduce用于遍历Q1, Q2, Q3等
    return acc + Object.entries(cur) // 获取当前子对象（如{Q1A1: "Yes"}）的键值对
      .reduce((accInner, [key, val]) => { // 内层reduce用于遍历子对象中的键值对
        // 判断条件：值不为'No' 且 points对象中存在对应的key，且其值为有效分数（非0或undefined）
        // 注意：如果points[key]可能是0，但0也应该计入，则只需判断 points[key] !== undefined
        if (val !== 'No' && points[key] !== undefined && points[key] !== null) {
          return accInner + points[key];
        }
        return accInner;
      }, 0); // 内层reduce的初始累加值为0
  }, 0); // 外层reduce的初始累加值为0

console.log(total); // 输出: 60

解析：

1. Object.values(values)：首先提取 values 对象中所有第一层的值，即 Q1, Q2, Q3 等子对象。
2. 外层 reduce：遍历这些子对象。acc 是总累加器，cur 是当前的子对象（例如 { Q1A1: "Yes" }）。
3. Object.entries(cur)：对于每个子对象，提取其键值对数组（例如 [['Q1A1', 'Yes']]）。
4. 内层 reduce：遍历子对象的键值对。accInner 是当前子对象的分数累加器，[key, val] 是当前的键值对。
5. 条件判断：val !== 'No' 确保只有非"No"的答案才考虑计分。points[key] !== undefined && points[key] !== null 确保在 points 对象中存在对应的键，并且其值有效。如果points[key]可能为0且0也应计入，则只需 points[key] !== undefined。
6. 如果条件满足，将 points[key] 的值加到 accInner 中。

这种方法简洁，直接在迭代过程中完成计算，适用于数据结构相对固定的情况。

方法二：构建查找表后进行过滤和求和

当数据量较大或需要更清晰地分离数据处理步骤时，可以先从 values 对象中构建一个符合条件的键的查找表，然后再用这个查找表去过滤和累加 points 对象中的分数。

const values = {
    Q1: { Q1A1: "Yes" },
    Q2: { Q2A1: "Yes" },
    Q3: { Q3A2: "No" },
};

const points = {
    Q1A1: 41,
    Q1A2: 0,
    Q2A1: 19,
    Q2A2: 0,
    Q3A1: 25,
    Q3A2: 5,
};

// 步骤1: 从values对象中构建一个符合条件的键的查找表
const lookupKeys = Object.values(values).reduce((acc, cur) => {
  // 假设每个子对象只有一个键值对
  const [key, val] = Object.entries(cur)[0];
  if (val === "Yes") { // 只有值为"Yes"的键才被添加到查找表中
    acc[key] = true; // 使用布尔值作为查找表的值，表示该键存在且符合条件
  }
  return acc;
}, {});

console.log("Lookup Table:", lookupKeys); // 输出: { Q1A1: true, Q2A1: true }

// 步骤2: 遍历points对象，根据查找表过滤并求和
const total = Object.entries(points)
  .filter(([key, score]) => lookupKeys[key] && score !== 0) // 过滤条件：键在查找表中存在 且 分数不为0
  .reduce((accumulator, [key, score]) => accumulator + score, 0); // 对过滤后的分数进行累加

console.log(total); // 输出: 60

解析：

1. 构建 lookupKeys：
   • Object.values(values).reduce(...)：遍历 values 对象的子对象。
   • Object.entries(cur)[0]：获取每个子对象内部的第一个（也是唯一一个）键值对。
   • if (val === "Yes") acc[key] = true;：如果值是 "Yes"，则将该键添加到 lookupKeys 对象中，值为 true，表示这是一个需要计分的有效键。
2. 过滤并求和：
   • Object.entries(points)：将 points 对象转换为键值对数组。
   • .filter(([key, score]) => lookupKeys[key] && score !== 0)：过滤这些键值对。只有当键存在于 lookupKeys 中（即 lookupKeys[key] 为 true）并且分数不为 0 时，才保留该项。
   • .reduce((accumulator, [key, score]) => accumulator + score, 0)：对过滤后的项进行累加，得到最终总和。

这种方法将数据准备和计算分成了两个清晰的阶段，提高了代码的可读性和模块化。

方法三：提取所有相关键到 Set 后进行过滤和求和

如果我们的条件仅仅是“values 对象中存在的键，无论其值是Yes还是No，只要在points中有对应分数就计入”，或者我们只关心特定条件的键（如"Yes"），并希望高效地检查键的存在性，可以使用 Set 结构来存储符合条件的键。

const values = {
    Q1: { Q1A1: "Yes" },
    Q2: { Q2A1: "Yes" },
    Q3: { Q3A2: "No" },
};

const points = {
    Q1A1: 41,
    Q1A2: 0,
    Q2A1: 19,
    Q2A2: 0,
    Q3A1: 25,
    Q3A2: 5,
};

// 步骤1: 从values对象中提取所有符合条件的键到Set
const pointKeysToSum = Object.values(values).reduce((acc, cur) => {
  const [key, val] = Object.entries(cur)[0]; // 获取子对象中的键值对
  if (val === "Yes") { // 假设我们只关心值为"Yes"的键
    acc.add(key); // 将符合条件的键添加到Set中
  }
  return acc;
}, new Set()); // 初始值为一个空的Set

console.log("Keys to Sum (Set):", pointKeysToSum); // 输出: Set(2) { 'Q1A1', 'Q2A1' }

// 步骤2: 遍历points对象，根据Set过滤并求和
const total = Object.entries(points)
  .filter(([key, score]) => pointKeysToSum.has(key)) // 过滤条件：键存在于Set中
  .reduce((accumulator, [key, score]) => accumulator + score, 0); // 对过滤后的分数进行累加

console.log(total); // 输出: 60

解析：

1. 构建 pointKeysToSum Set：
   • Object.values(values).reduce(...)：遍历 values 对象的子对象。
   • if (val === "Yes") acc.add(key);：根据条件（此处为 val === "Yes"）将键添加到 Set 中。Set 自动处理重复键，确保每个键只出现一次。
2. 过滤并求和：
   • Object.entries(points)：将 points 对象转换为键值对数组。
   • .filter(([key, score]) => pointKeysToSum.has(key))：使用 Set.prototype.has() 方法高效地检查键是否存在于 pointKeysToSum 中。
   • .reduce((accumulator, [key, score]) => accumulator + score, 0)：对过滤后的项进行累加。

Set 的 has() 方法具有平均 O(1) 的时间复杂度，这使得它在处理大量键的查找时比数组的 includes() 方法（O(n)）更高效。

注意事项与总结

• 条件逻辑： 教程中演示了根据 val === "Yes" 或 val !== "No" 进行判断。实际应用中，你需要根据具体业务需求调整条件。
• 键值类型： 确保 values 中提取的键与 points 中的键类型一致（通常都是字符串）。
• 分数有效性： 在累加分数时，考虑 points[key] 可能为 undefined、null 或 0 的情况。根据业务需求决定这些值是否应该计入总和。
• 数据结构假设： 示例中 values 对象的每个子对象（如 Q1）内部只有一个键值对。如果存在多个，你需要调整 Object.entries(cur)[0] 的逻辑，可能需要再次迭代。
• 性能考量：
  • 对于小型数据集，所有方法性能差异不大。
  • 对于大型数据集，Set 或构建查找表（方法二和方法三）通常比嵌套 reduce（方法一）更具优势，因为它们将查找操作的复杂度从 O(N*M) 降低到 O(N+M)，其中 N 和 M 分别是两个对象的大小。Set.prototype.has() 的 O(1) 平均时间复杂度在查找效率上表现突出。
• 可读性： 选择最能清晰表达意图的方法。对于复杂逻辑，分阶段构建查找表或 Set 可能比深度嵌套的 reduce 更易读。

通过本文介绍的几种方法，你可以根据实际需求和偏好，灵活选择在JavaScript中根据键值比较两个对象并计算总和的最佳策略。理解这些数组和对象方法的强大功能，将有助于你更高效地处理各种数据聚合任务。

本篇关于《JavaScript中根据键值比较两个对象并计算总和的教程 》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于文章的相关知识，请关注golang学习网公众号！