JavaScript数组按Drug1/Drug2去重并保留高riskingRate的Drug对象

这个需求其实就是按Drug1+Drug2组合去重，保留每组中riskingRate优先级最高的对象，我之前做过类似的场景，核心思路是先分组再筛选，下面给你具体的实现方案：

核心逻辑 #

1. 先给riskingRate的优先级做个映射（因为字符串没法直接比较大小），把每个rate转换成可比较的数值；
2. 遍历原数组，用Drug1+Drug2的组合作为唯一键，把相同组合的对象归为一组；
3. 遍历过程中，每组只保留当前riskingRate优先级最高的对象；
4. 最后把分组里的所有结果提取出来，就是去重后的数组。

JavaScript 实现示例 #

// 定义riskingRate的优先级映射，数值越大优先级越高
const ratePriority = {
  'X': 5,
  'D': 4,
  'C': 3,
  'B': 2,
  'A': 1
};

// 你的示例数组
const originalDrugs = [
  { Drug1: 'A', Drug2: 'B', riskingRate: 'A' },
  { Drug1: 'C', Drug2: 'D', riskingRate: 'B' },
  { Drug1: 'E', Drug2: 'F', riskingRate: 'C' },
  { Drug1: 'A', Drug2: 'B', riskingRate: 'X' },
  { Drug1: 'A', Drug2: 'B', riskingRate: 'D' }
];

// 用对象分组存储每个Drug组合的最优项
const groupedDrugs = {};

originalDrugs.forEach(drug => {
  // 生成唯一分组键，这里用破折号拼接，如果你Drug里有破折号可以换其他分隔符，比如|
  const key = `${drug.Drug1}-${drug.Drug2}`;
  
  // 如果分组里没有这个键，或者当前对象的rate优先级更高，就替换
  if (!groupedDrugs[key] || ratePriority[drug.riskingRate] > ratePriority[groupedDrugs[key].riskingRate]) {
    groupedDrugs[key] = drug;
  }
});

// 把分组对象的值转换成数组，就是最终结果
const uniqueDrugs = Object.values(groupedDrugs);

console.log(uniqueDrugs);
// 输出结果会保留第1、2、3个对象，完全符合你的需求

Python 实现示例（如果用Python的话） #

# 优先级映射
rate_priority = {'X':5, 'D':4, 'C':3, 'B':2, 'A':1}

original_drugs = [
    {'Drug1': 'A', 'Drug2': 'B', 'riskingRate': 'A'},
    {'Drug1': 'C', 'Drug2': 'D', 'riskingRate': 'B'},
    {'Drug1': 'E', 'Drug2': 'F', 'riskingRate': 'C'},
    {'Drug1': 'A', 'Drug2': 'B', 'riskingRate': 'X'},
    {'Drug1': 'A', 'Drug2': 'B', 'riskingRate': 'D'}
]

grouped = {}

for drug in original_drugs:
    # 用元组作为分组键，Python里元组可以直接当字典的键
    key = (drug['Drug1'], drug['Drug2'])
    # 对比优先级，保留更高的那个
    if key not in grouped or rate_priority[drug['riskingRate']] > rate_priority[grouped[key]['riskingRate']]:
        grouped[key] = drug

unique_drugs = list(grouped.values())
print(unique_drugs)

注意事项 #

• 如果你的riskingRate优先级有变化，只需要修改映射表就行，非常灵活；
• 如果Drug1/Drug2包含特殊字符（比如破折号），建议改用JSON.stringify([drug.Drug1, drug.Drug2])（JS）或者元组（Python）作为键，避免键冲突；
• 这个方法的时间复杂度是O(n)，遍历一次数组就搞定，效率很高。

内容的提问来源于stack exchange，提问作者john sadeghi