ES6(2015年ECMAScript)版本:

Const counts = [4,9,15,6,2]; Const goal = 5; Const输出=计数。reduce((prev, curr) =>abs(curr - goal) <数学。腹肌(前一球)?Curr: prev); console.log(输出);

为了可重用性，您可以封装一个支持占位符的curry函数(http://ramdajs.com/0.19.1/docs/#curry或https://lodash.com/docs#curry)。这提供了很大的灵活性，取决于你需要什么:

const getnearest = _。Curry((计数，目标)=> { 返回计数。reduce((prev, curr) =>abs(curr - goal) <数学。腹肌(前一球)?Curr: prev); })； const closestToFive = getnearest (_， 5); const output = closestToFive([4,9,15,6,2]); console.log(输出); < script src = " https://cdn.jsdelivr.net/npm/lodash@4.17.20 lodash.min.js " > < /脚本>

我不知道我是否应该回答一个老问题，但由于这篇文章首先出现在谷歌搜索中，我希望你能原谅我在这里添加我的解决方案和我的2c。

由于懒惰，我无法相信这个问题的解决方案会是一个LOOP，所以我搜索了更多，并返回了过滤器函数:

var myArray = [2, 42, 82, 122, 162, 202, 242, 282, 322, 362];
var myValue = 80;

function BiggerThan(inArray) {
  return inArray > myValue;
}

var arrBiggerElements = myArray.filter(BiggerThan);
var nextElement = Math.min.apply(null, arrBiggerElements);
alert(nextElement);

就这些!

ES5版本:

Var计数= [4,9,15,6,2]， 目标= 5; Var最接近=计数。Reduce(函数(prev, curr) { 返回(数学。abs(curr - goal) <数学。腹肌(前一球)?Curr: prev); })； console.log(最近的);

我喜欢Fusion的方法，但其中有一个小错误。这样是正确的:

    function closest(array, number) {
        var num = 0;
        for (var i = array.length - 1; i >= 0; i--) {
            if(Math.abs(number - array[i]) < Math.abs(number - array[num])){
                num = i;
            }
        }
        return array[num];
    }

它也更快一点，因为它使用了改进的for循环。

最后，我这样写函数:

    var getClosest = function(number, array) {
        var current = array[0];
        var difference = Math.abs(number - current);
        var index = array.length;
        while (index--) {
            var newDifference = Math.abs(number - array[index]);
            if (newDifference < difference) {
                difference = newDifference;
                current = array[index];
            }
        }
        return current;
    };

我用console.time()测试了它，它比其他函数略快。

适用于无序数组

虽然这里有一些很好的解决方案，但JavaScript是一种灵活的语言，它为我们提供了以多种不同方式解决问题的工具。 当然，这一切都取决于你的风格。如果你的代码更实用，你会发现减少变化是合适的，即:

  arr.reduce(function (prev, curr) {
    return (Math.abs(curr - goal) < Math.abs(prev - goal) ? curr : prev);
  });

然而，有些人可能会发现这很难阅读，这取决于他们的编码风格。因此，我提出了一种新的解决方法:

  var findClosest = function (x, arr) {
    var indexArr = arr.map(function(k) { return Math.abs(k - x) })
    var min = Math.min.apply(Math, indexArr)
    return arr[indexArr.indexOf(min)]
  }

  findClosest(80, [2, 42, 82, 122, 162, 202, 242, 282, 322, 362]) // Outputs 82

与使用Math.min找到最小值的其他方法相反。应用，这个不需要输入数组arr排序。我们不需要关心索引或者事先排序。

为了清晰起见，我将逐行解释代码:

arr.map(function(k) { return Math.abs(k - x) }) Creates a new array, essentially storing the absolute values of the given numbers (number in arr) minus the input number (x). We'll look for the smallest number next (which is also the closest to the input number) Math.min.apply(Math, indexArr) This is a legit way of finding the smallest number in the array we've just created before (nothing more to it) arr[indexArr.indexOf(min)] This is perhaps the most interesting part. We have found our smallest number, but we're not sure if we should add or subtract the initial number (x). That's because we used Math.abs() to find the difference. However, array.map creates (logically) a map of the input array, keeping the indexes in the same place. Therefore, to find out the closest number we just return the index of the found minimum in the given array indexArr.indexOf(min).

我创建了一个箱子来演示它。

这个解决方案使用ES5存在量词数组#some，它允许在满足条件时停止迭代。

与array# reduce相反，它不需要为一个结果迭代所有元素。

在回调中，获取搜索值与实际项之间的绝对增量，并与最后的增量进行比较。如果大于或等于，迭代将停止，因为所有其他具有delta的值都大于实际值。

如果回调中的增量较小，则实际的项被分配给结果，增量保存在lastDelta中。

最后，取具有相等增量的较小值，如下面22的示例，结果为2。

如果有更大的优先级值，delta检查必须从以下更改:

if (delta >= lastDelta) {

to:

if (delta > lastDelta) {
//       ^^^ without equal sign

这将得到22，结果为42(较大值的优先级)。

这个函数需要数组中排序的值。

优先级较小的代码:

function closestValue(array, value) { var result, lastDelta; array.some(function (item) { var delta = Math.abs(value - item); if (delta >= lastDelta) { return true; } result = item; lastDelta = delta; }); return result; } var data = [2, 42, 82, 122, 162, 202, 242, 282, 322, 362]; console.log(21, closestValue(data, 21)); // 2 console.log(22, closestValue(data, 22)); // 2 smaller value console.log(23, closestValue(data, 23)); // 42 console.log(80, closestValue(data, 80)); // 82

优先级较高的代码:

function closestValue(array, value) { var result, lastDelta; array.some(function (item) { var delta = Math.abs(value - item); if (delta > lastDelta) { return true; } result = item; lastDelta = delta; }); return result; } var data = [2, 42, 82, 122, 162, 202, 242, 282, 322, 362]; console.log(21, closestValue(data, 21)); // 2 console.log(22, closestValue(data, 22)); // 42 greater value console.log(23, closestValue(data, 23)); // 42 console.log(80, closestValue(data, 80)); // 82