对于一个较小的范围，最简单的方法是有一个map数组，例如，用你的例子来说，第80个条目的值是82。对于一个更大、更稀疏的范围，可能的方法是二分搜索。

使用查询语言，您可以查询与输入数字任意一侧有一定距离的值，然后对结果减少的列表进行排序。但是SQL并没有一个“下一个”或“上一个”的好概念，来给你一个“干净”的解决方案。

其他答案建议你需要遍历整个数组:

计算每个元素的偏差 跟踪最小偏差及其元素 最后，在遍历整个数组后，返回具有最小偏差的元素。

如果数组已经排序了，那就没有意义了。没有必要计算所有的偏差。例如，在一个100万个元素的有序集合中，你只需要计算~19个偏差(最多)来找到你的匹配。你可以用二进制搜索方法来实现:

function findClosestIndex(arr, element) {
    let from = 0, until = arr.length - 1
    while (true) {
        const cursor = Math.floor((from + until) / 2);
        if (cursor === from) {
            const diff1 = element - arr[from];
            const diff2 = arr[until] - element;
            return diff1 <= diff2 ? from : until;
        }

        const found = arr[cursor];
        if (found === element) return cursor;

        if (found > element) {
            until = cursor;
        } else if (found < element) {
            from = cursor;
        }
    }
}

结果:

console.log(findClosestIndex([0, 1, 2, 3.5, 4.5, 5], 4));
// output: 3

console.log(findClosestIndex([0, 1, 2, 3.49, 4.5, 5], 4));
// output: 4

console.log(findClosestIndex([0, 1, 2, 3.49, 4.5, 5], 90));
// output: 5

console.log(findClosestIndex([0, 1, 2, 3.49, 4.5, 5], -1));
// output: 0

这里的另一个变体是圆形范围，从头到脚连接，只接受给定输入的最小值。这帮助我获得了一个加密算法的字符代码值。

function closestNumberInCircularRange(codes, charCode) {
  return codes.reduce((p_code, c_code)=>{
    if(((Math.abs(p_code-charCode) > Math.abs(c_code-charCode)) || p_code > charCode) && c_code < charCode){
      return c_code;
    }else if(p_code < charCode){
      return p_code;
    }else if(p_code > charCode && c_code > charCode){
      return Math.max.apply(Math, [p_code, c_code]);
    }
    return p_code;
  });
}

对于一个较小的范围，最简单的方法是有一个map数组，例如，用你的例子来说，第80个条目的值是82。对于一个更大、更稀疏的范围，可能的方法是二分搜索。

使用查询语言，您可以查询与输入数字任意一侧有一定距离的值，然后对结果减少的列表进行排序。但是SQL并没有一个“下一个”或“上一个”的好概念，来给你一个“干净”的解决方案。

如果数组像你的例子中那样排序，你可以使用二进制搜索来获得O(log n)更好的时间复杂度。

const myArray = [2, 42, 82, 122, 162, 202, 242, 282, 322, 362]; const binaryClosestIdx = (arr, target) => { let start = 0; let end = arr.length - 1; let mid = Math.floor((start + end) / 2); while (1) { if (arr[mid] === target) { return mid; } else if (start >= end) { break; } else if (arr[mid] > target) { end = mid - 1; } else { start = mid + 1; } mid = Math.floor((start + end) / 2); } // Return the closest between the last value checked and it's surrounding neighbors const first = Math.max(mid - 1, 0); const neighbors = arr.slice(first, mid + 2); const best = neighbors.reduce((b, el) => Math.abs(el - target) < Math.abs(b - target) ? el : b); return first + neighbors.indexOf(best); } const closestValue = myArray[binaryClosestIdx(myArray, 80)]; console.log(closestValue);

工作原理:

它将目标值与数组的中间元素进行比较。如果中间的元素更大，我们可以忽略它后面的每个元素，因为它们会更大。同样，如果中间的元素更小，我们可以忽略它之前的所有元素。 如果找到了目标值，则返回它，否则将最后测试的值与其周围的相邻值进行比较，因为最近的值只能在这3个值之间。

最有效的方法是二分查找。然而，即使是简单的解决方案，当下一个数字与当前数字进一步匹配时，也可以退出。这里几乎所有的解决方案都没有考虑到数组是有序的，并且迭代整个:/

const closest = (orderedArray, value, valueGetter = item => item) => orderedArray.find((item, i) => i === orderedArray.length - 1 || Math.abs(value - valueGetter(item)) < Math.abs(value - valueGetter(orderedArray[i + 1]))); var data = [2, 42, 82, 122, 162, 202, 242, 282, 322, 362]; console.log('21 -> 2', closest(data, 21) === 2); console.log('22 -> 42', closest(data, 22) === 42); // equidistant between 2 and 42, select highest console.log('23 -> 42', closest(data, 23) === 42); console.log('80 -> 82', closest(data, 80) === 82);

这也可以在非原语上运行，例如，nearest (data, 21, item => item.age)

将find更改为findIndex以返回数组中的索引。