javascript：如何在关联数组中找到最接近某个值的键？

我有点像

var keyVals = Array;
keyVals['23'] = 234;
keyVals['58'] = 'sunshine';
keyVals['172'] = 'lolipops';

newVar = 76;

我如何找到数组中哪个键的值（一旦变成数字）最接近我的newVar？ 23、58、172中哪一个最接近我的76

谢谢

首先：
如果使用数字类型值作为键，则它们必须保留为数字。
应该是23，而不是“23”
否则，23将被视为字符串“23”，无法对数字进行数学测试

var keyVals = Array;
keyVals[23] = 234; // keyVals[23], not keyVals['23']
keyVals[58] = 'sunshine';
keyVals[172] = 'lolipops'

要查找最近的密钥，
只需在你的钥匙之间循环，并搜索最近的一个

dist = Number.POSITIVE_INFINITY; // set the distance from key to value
closestkey = -1; // closest key variable
for(i in keyVals) {
    // i is the key, keyVals[i] is the value
    newdist = Math.abs(newVar - i); // distance from current key to value
    if (newdist < dist) {
        // we found a key closer to the value
        dist = newdist; // set new smallest distance
        closestkey = i; // set the value to the current key
    }
}
// Now closestkey is the key to your closest variable

dist=Number.POSITIVE_∞；//设置从关键点到值的距离
closestkey=-1；//最近键变量
用于（i单位：keyVals）{
//i是键，keyVals[i]是值
newdist=Math.abs（newVar-i）；//从当前键到值的距离
if（新距离<距离）{
//我们找到了一个更接近该值的键
dist=newdist；//设置新的最小距离
closestkey=i；//将值设置为当前键
}
}
//现在closestkey是最接近的变量的键

首先，请注意，从技术上讲，您正在创建一个对象，因此keyVals的首选赋值是

keyVals={}

var newVar = 31,
    keyNum,
    key,
    diff,
    keyVals = {},
    closest = {
        key: null,
        diff: null
    };

keyVals['23'] = 234;
keyVals['58'] = 'sunshine';
keyVals['172'] = 'lolipops';

for(key in keyVals) {
    if(keyVals.hasOwnProperty(key)) {
        keyNum = parseInt(key,10);
        diff = Math.abs(newVar - keyNum);

        if(!closest.key || diff < closest.diff) {
            closest.key = key;
            closest.diff = diff;
        }
    }
}

var newVar=31，
凯纳姆，
钥匙
差异，
keyVals={}，
最近的={
key:null，
差异：空
};
keyVals['23']=234；
keyVals['58']='sunshine'；
keyVals['172']='lolipops'；
用于（输入keyVals）{
if（keyVals.hasOwnProperty（键））{
keyNum=parseInt（键，10）；
diff=Math.abs（newVar-keyNum）；
如果（！nexist.key | | diff

---

当

for

循环完成时，

最近的.key

将包含与

newVar

最近匹配的索引。为了增加保护，请使用

hasOwnProperty

确保您不会意外地迭代

keyVals

原型之一的属性（当然，在这种特定情况下这是不太可能的）。

但请注意，可能有两个值最接近

newVar

例如：

keyVals[23] = 234;
keyVals[129] = 'aaa';
keyVals[172] = 'lolipops';

23和129最接近76

那么

将提示“与76最近的键为[23129]，差值为53”

或者用你的阵列

keyVals[23] = 234;
keyVals[58] = 'sunshine';
keyVals[172] = 'lolipops';

---

将提醒“与76最接近的键为[58]，相差18”

正如其他人指出的那样，

对象（又称散列）是将键映射到值时使用的最佳数据结构；记住这一点，您将看到将映射键预排序为数字顺序的性能优势

// Helper method, you could also use underscore.js's `_.keys`
function getKeys(object) {
    var keys = [];
    for (var key in object) {
        if (object.hasOwnProperty(key)) {
            keys.push(key);
        }
    }
    return keys;
};

// Lookup table.
var keyVals = {
    23: "234",
    58: "sunshine",
    172: "lollypops"
};

// Extract the keys from the lookup table and sort them into numerical order.
var sortedKeys = getKeys(keyVals).sort(function (a, b) {
    return a - b;
});

// Returns the closest key in the `keyVals` lookup table for the supplied value.
function getClosestIndex(value) {
    var i;

    // Walk through the sorted keys array and stop when the next value is greater.
    for (i = 0; i < sortedKeys.length; i++) {
        if (sortedKeys[i] > value) {

            // Either return the previous key, or zero if this was the first.
            return (i === 0) ? sortedKeys[0] : sortedKeys[i - 1];
        }
    } 

    // We reached the end, so the value is greater than the highest key we have.
    return sortedKeys[i];
}

//Helper方法，也可以使用下划线.js的`.\keys`
函数getKeys（对象）{
var键=[]；
for（对象中的变量键）{
if（object.hasOwnProperty（key））{
按键。按（键）；
}
}
返回键；
};
//查找表。
var-keyVals={
23: "234",
58:“阳光”，
172：“棒棒糖”
};
//从查找表中提取键并按数字顺序排序。
var sortedKeys=getKeys（keyVals）。sort（函数a、b）{
返回a-b；
});
//返回“keyVals”查找表中与所提供值最接近的键。
函数getClosestIndex（值）{
var i；
//遍历排序键数组，并在下一个值较大时停止。
对于（i=0；i值）{
//返回上一个键，如果这是第一个键，则返回零。
返回（i==0）？sortedKeys[0]：sortedKeys[i-1]；
}
} 
//我们到达了终点，因此该值大于我们拥有的最高键。
返回分拣机[i]；
}

显然，如果你的
keyVals
映射很小（少于1000个条目），那么这种优化是非常学术的（但仍然很有趣）：
你没有将数组用作数组。这不是数组，而是对象。。。还有
var-keyVals=Array
？如果要使用构造函数，请编写
var keyVals=new Array（）或-在您的例子中-
var keyVals=new Object（）。但是您最好使用
var-keyVals=[]
用于数组，var keyVals={}
用于对象他为什么不将其用作数组？所有属性都是数字。数组可以是稀疏的。@user1600680:打开控制台，粘贴代码段并键入
keyVals.length
（返回
1
），这就是它不是数组的原因。然后尝试
foo=[]；foo['123']=bar；foo.length
后者返回
123
…你的意思是因为他不调用构造函数？那么是的，没错。我想那一定是打字错误。使用函数对象将是一种非常奇怪的方式。它是23还是“23”无关紧要。在JavaScript中，所有属性都被视为字符串。字符串可以很容易地根据数字进行测试，只要使用
number（）
，
parseInt（）
，
parseFloat（）
，或类似的
+someString
将其强制为数字，我就可以将原始字符串更改为数字加载，谢谢大家，谢谢你们的帮助，先生们。找到了我的问题的答案，并在这里学到了很多，这要感谢您的注释良好的代码。我很感激这一切。
// Helper method, you could also use underscore.js's `_.keys`
function getKeys(object) {
    var keys = [];
    for (var key in object) {
        if (object.hasOwnProperty(key)) {
            keys.push(key);
        }
    }
    return keys;
};

// Lookup table.
var keyVals = {
    23: "234",
    58: "sunshine",
    172: "lollypops"
};

// Extract the keys from the lookup table and sort them into numerical order.
var sortedKeys = getKeys(keyVals).sort(function (a, b) {
    return a - b;
});

// Returns the closest key in the `keyVals` lookup table for the supplied value.
function getClosestIndex(value) {
    var i;

    // Walk through the sorted keys array and stop when the next value is greater.
    for (i = 0; i < sortedKeys.length; i++) {
        if (sortedKeys[i] > value) {

            // Either return the previous key, or zero if this was the first.
            return (i === 0) ? sortedKeys[0] : sortedKeys[i - 1];
        }
    } 

    // We reached the end, so the value is greater than the highest key we have.
    return sortedKeys[i];
}