在平局的情况下，如何在javascript中返回较小的数字？

我需要编写一个函数，它接受两个输入，‘target’（整数）和‘values’（整数列表），并找到‘values’中最接近‘target’的数字。我得出了以下结论：

var targetNum = 0;
var valuesArr = [2, 4, 6, 8, 10];

function closestToTarget(target, values) {
    var currVal = values[0];
    var diff = Math.abs(target - currVal);
    for (var i = 0; i < values.length; i++) {
        var currDiff = Math.abs(target - values[i]);
        if (currDiff < diff) {
            diff = currDiff;
            currVal = values[i];
        }
    }
    return currVal;
}
alert(closestToTarget(targetNum, valuesArr));

var targetNum=0；
var估价师=[2,4,6,8,10]；
函数接近目标（目标、值）{
var currVal=值[0]；
var diff=数学绝对值（目标-当前值）；
对于（变量i=0；i

该函数起作用，但在平局的情况下，我无法返回较小的值。我能想到的最好的办法是以下几点，但都不起作用：

function closestToTarget(target, values) {
    var currVal = values[0];
    var diff = Math.abs(target - currVal);
    for (var i = 0; i < values.length; i++) {
        var currDiff = Math.abs(target - values[i]);
        if (currDiff < diff) {
            diff = currDiff;
            currVal = values[i];
        }
        else if (currDiff == diff) {
            return Math.min[currVal, values[i]];
        }
        else {
            return currVal[i - 1];
        }
    }
    return currVal;
}

函数接近目标（目标、值）{
var currVal=值[0]；
var diff=数学绝对值（目标-当前值）；
对于（变量i=0；i

---

在平局的情况下，如何在JavaScript中返回较小的数字？

您的代码看起来是可行的，请尝试将

Math.min[currVal，values[I]

更改为

Math.min（currVal，values[I]）

，如果您的值是有序的（简单的语法问题）

正如kojow7所提到的，只要对

值进行排序，第一个函数也应该工作

否则，您应该尝试执行
currVal=Math.min（…）
并继续迭代，然后在循环后返回
currVal
，而不是
return Math.min（…）
。这只是确保您检查
值
数组中的每个值，以确保没有遗漏任何内容（但如果它是有序的，则无需继续检查，因为差异只会增加）。
您的代码看起来会起作用，请尝试将
Math.min[currVal，values[i]
更改为
Math.min（currVal，values[i]）
如果您的值是有序的（简单的语法问题），应该可以使用

正如kojow7所提到的，只要对
值进行排序，第一个函数也应该工作

否则，您应该尝试执行
currVal=Math.min（…）
并不断迭代，然后在循环后返回
currVal
，而不是
return Math.min（…）
。这只是确保检查
values
数组中的每个值，以确保没有遗漏任何内容（但如果是订购的，则无需继续检查，因为差异只会增加）。
诀窍是，当您找到新的最佳差异时，除了记录差异（
bestDiff
），您还可以记录导致该差异的值（
bestVal
）

所以现在，如果你遇到一个平局（
currDiff==bestDiff
），你需要检查它是否是一个更好的平局，也就是说，检查当前值是否小于记录值（
currVal
）。如果是，那么我们更新最佳值（同时更新
bestDiff
和
bestVal
）

诀窍在于，当您找到一个新的最佳差异时，除了记录差异（
bestDiff
），您还可以记录导致该差异的值（
bestVal
）

所以现在，如果你遇到一个平局（
currDiff==bestDiff
），你需要检查它是否是一个更好的平局，也就是说，检查当前值是否小于记录值（
currVal
）。如果是，那么我们更新最佳值（同时更新
bestDiff
和
bestVal
）

你的想法应该行得通，但你也可以使用你的第一个功能，但添加一些东西，检查末端是否有较低的领带：

function closestToTarget(target, values) {
    var currVal = values[0];
    var diff = Math.abs(target - currVal);
    for (var i = 0; i < values.length; i++) {
        var currDiff = Math.abs(target - values[i]);
        if (currDiff < diff) {
            diff = currDiff;
            currVal = values[i];
        }
    }

    // We found the closest but now check if there's a smaller tie
    if (currVal > target && values.indexOf(target - diff) > -1 ) {
        return target - diff;
    }
    else {
    // if not just return what we originally found
        return currVal;
    }
}

函数接近目标（目标、值）{
var currVal=值[0]；
var diff=数学绝对值（目标-当前值）；
对于（变量i=0；itarget&&values.indexOf（target-diff）>-1）{
返回目标-差异；
}
否则{
//如果不只是归还我们最初发现的东西
返回电流；
}
}

你的想法应该行得通，但你也可以使用你的第一个功能，但要添加一些东西，检查末端是否有较低的领带：

function closestToTarget(target, values) {
    var currVal = values[0];
    var diff = Math.abs(target - currVal);
    for (var i = 0; i < values.length; i++) {
        var currDiff = Math.abs(target - values[i]);
        if (currDiff < diff) {
            diff = currDiff;
            currVal = values[i];
        }
    }

    // We found the closest but now check if there's a smaller tie
    if (currVal > target && values.indexOf(target - diff) > -1 ) {
        return target - diff;
    }
    else {
    // if not just return what we originally found
        return currVal;
    }
}

函数接近目标（目标、值）{
var currVal=值[0]；
var diff=数学绝对值（目标-当前值）；
对于（变量i=0；itarget&&values.indexOf（target-diff）>-1）{
返回目标-差异；
}
否则{
//如果不只是归还我们最初发现的东西
返回电流；
}
}

除了语法错误（缺少括号），您还可以使用一些ES6语法编写更简洁的函数：


函数接近目标（目标、值）{
const m=Math.min（…values.map（v=>Math.abs（target-v））；
返回Math.min（…values.filter（v=>Math.abs（target-v==m））；
}
var估价师=[2,4,6,8,10]；
//试试几个数字
对于（变量i=1；i<12；i++）{
console.log（i，接近目标（i，估价师））；
}function closestToTarget(target, values) {
    var currVal = values[0];
    var diff = Math.abs(target - currVal);
    for (var i = 0; i < values.length; i++) {
        var currDiff = Math.abs(target - values[i]);
        if (currDiff < diff) {
            diff = currDiff;
            currVal = values[i];
        }
    }

    // We found the closest but now check if there's a smaller tie
    if (currVal > target && values.indexOf(target - diff) > -1 ) {
        return target - diff;
    }
    else {
    // if not just return what we originally found
        return currVal;
    }
}

function findClosest(inpt, ar) {
   var minDiff = Math.abs(ar[0] - inpt);
   var res = ar[0];
   for (var i = 1; i < ar.length; i++) {
       if(Math.abs((ar[i] - inpt)) < minDiff)
           res = ar[i];
   }
   return res;
}