对比JavaScript数组对象，返回ratio最接近的数值配对

嘿，这个需求我之前处理过，刚好可以给你两种实用的解决方案，你可以根据实际场景来选择：

场景1：为每个Array1元素找到Array2中最接近的元素（允许重复配对） #

这种方式会逐个遍历Array1里的元素，在Array2中找出和它ratio差值最小的元素——哪怕Array2里的同一个元素被多次配对。

实现代码 #

const array1 = [
  { "index": 3, "ratio": 1.9310344827586208 },
  { "index": 0, "ratio": 2.4122497055359244 },
  { "index": 2, "ratio": 2.5 },
  { "index": 1, "ratio": 1 }
];

const array2 = [
  { "index": 0, "ratio": 0.6670000000000006 },
  { "index": 2, "ratio": 1 },
  { "index": 3, "ratio": 1 },
  { "index": 1, "ratio": 2.409638554216892 }
];

function findClosestPairs(arr1, arr2) {
  return arr1.map((elem1, idx1) => {
    // 计算当前元素和Array2所有元素的ratio差值绝对值
    const diffs = arr2.map((elem2, idx2) => ({
      idx2,
      diff: Math.abs(elem1.ratio - elem2.ratio)
    }));
    // 找出差值最小的那个元素
    const closest = diffs.reduce((prev, curr) => 
      curr.diff < prev.diff ? curr : prev
    );
    return { array1: idx1, array2: closest.idx2 };
  });
}

// 运行并打印结果
const result = findClosestPairs(array1, array2);
console.log(result);

运行结果 #

[
  { array1: 0, array2: 3 },  // 1.931 vs 2.409，差值最小
  { array1: 1, array2: 3 },  // 2.412 vs 2.409，差值约0.0026（就是你示例里提到的最接近配对）
  { array1: 2, array2: 3 },  // 2.5 vs 2.409，差值0.091
  { array1: 3, array2: 1 }   // 1 vs 1，差值为0
]

场景2：无重复的最优配对（每个元素仅配对一次） #

如果你的需求是让两个数组的元素一一对应，每个元素只能被配对一次，那可以用贪心算法：每次找出全局差值最小的一对，标记已配对的元素，重复直到所有元素都完成匹配。

实现代码 #

function findUniqueClosestPairs(arr1, arr2) {
  // 给每个元素带上原数组的索引，同时复制一份避免修改原数据
  const arr1WithIdx = arr1.map((elem, idx) => ({ ...elem, arrIdx: idx }));
  const arr2WithIdx = arr2.map((elem, idx) => ({ ...elem, arrIdx: idx }));
  
  const pairs = [];
  
  while (arr1WithIdx.length > 0 && arr2WithIdx.length > 0) {
    let minDiff = Infinity;
    let bestPair = null;
    let arr1RemoveIndex = -1;
    let arr2RemoveIndex = -1;
    
    // 遍历所有可能的配对，找到差值最小的那一对
    arr1WithIdx.forEach((elem1, idx1) => {
      arr2WithIdx.forEach((elem2, idx2) => {
        const currentDiff = Math.abs(elem1.ratio - elem2.ratio);
        if (currentDiff < minDiff) {
          minDiff = currentDiff;
          bestPair = { array1: elem1.arrIdx, array2: elem2.arrIdx };
          arr1RemoveIndex = idx1;
          arr2RemoveIndex = idx2;
        }
      });
    });
    
    // 把最优配对加入结果
    pairs.push(bestPair);
    // 移除已经配对的元素，避免重复匹配
    arr1WithIdx.splice(arr1RemoveIndex, 1);
    arr2WithIdx.splice(arr2RemoveIndex, 1);
  }
  
  return pairs;
}

// 运行并打印结果
const uniqueResult = findUniqueClosestPairs(array1, array2);
console.log(uniqueResult);

运行结果 #

[
  { array1: 3, array2: 1 },  // 差值为0（全局最小的配对）
  { array1: 1, array2: 3 },  // 差值约0.0026（你示例里的最接近配对）
  { array1: 0, array2: 2 },  // 1.931 vs 1，差值0.931
  { array1: 2, array2: 0 }   // 2.5 vs 0.667，差值1.833
]

额外说明 #

• 场景1实现简单、性能较好，适合不需要限制配对唯一性的场景；
• 场景2适合需要严格一一配对、无重复的场景；
• 如果你的需求是找出所有可能配对中最接近的前N对，可以先计算所有配对的差值，排序后取前N个即可。

内容的提问来源于stack exchange，提问作者Shakti Patel