Javascript 如果索引不存在，则获取对象中的数据

我有一个对象，其数据如下：

var data = {
    '4': [1, 2, 3],
    '5': [1, 2, 3],
    '6': [1, 2, 3],
    '7': [1, 2, 3],
    '8': [1, 2, 3],
    '9': [1, 2, 3],
    '10': [1, 2, 3],
    '11': [1, 2, 3],
    '12': [1, 2, 3],
    '15': [1, 9, 3],
    '18': [1, 2, 3],
    '21': [1, 8, 3],
    '24': [1, 2, 3],
    '30': [1, 2, 3],
    '36': [1, 2, 3],
    '42': [1, 20, 3]
}

现在我想访问以下数据：

var result = data[i][1];

如果i=15，则结果为9

---

但是如果给定的索引不存在，我需要总是得到下一个较低的索引。所以，如果i=16，结果也应该是9。如果i=23，结果为8；对于i=999，结果为20。我该怎么做呢？

您必须在数组中向下循环搜索该属性。假设输入是您要查找的输入

for (var i = input; i > 0; i--) { // Looping incrementing down
    if (data.hasOwnProperty(i)) {
        result = data[i][1];
        break;
    }
}

---

hasOwnProperty方法检查数据数组是否有可用的索引，如果有，则在设置结果后中断循环。

您必须在数组中向下循环搜索该属性。假设输入是您要查找的输入

for (var i = input; i > 0; i--) { // Looping incrementing down
    if (data.hasOwnProperty(i)) {
        result = data[i][1];
        break;
    }
}

---

hasOwnProperty方法检查数据数组是否有可用的索引，如果有，则在设置结果后中断循环。

您需要查找索引请求，如果找不到，则从索引中减去一个，然后重试。比如：

function getItem(i,j) {
    if (i < 0) {
        // assuming no negative keys exists
        return null;   // or throw an error if you prefer
    }
    if (data[i]) {
        return data[i][j];
    }
    else {
         return getItem(i-1,j);
    }
}

---

您需要查找索引请求，如果找不到，请从索引中减去一个，然后重试。比如：

function getItem(i,j) {
    if (i < 0) {
        // assuming no negative keys exists
        return null;   // or throw an error if you prefer
    }
    if (data[i]) {
        return data[i][j];
    }
    else {
         return getItem(i-1,j);
    }
}

---

要将其四舍五入到最接近的数字，请尝试使用以下方法：

var data = {
    '4': [ 1, 2, 3 ],
    '5': [ 1, 2, 3 ],
    '6': [ 1, 2, 3 ],
    '7': [ 1, 2, 3 ],
    '8': [ 1, 2, 3 ],
    '9': [ 1, 2, 3 ],
    '10': [ 1, 2, 3 ],
    '11': [ 1, 2, 3 ],
    '12': [ 1, 2, 3 ],
    '15': [ 1, 9, 3 ],
    '18': [ 1, 2, 3 ],
    '21': [ 1, 8, 3 ],
    '24': [ 1, 2, 3 ],
    '30': [ 1, 2, 3 ],
    '36': [ 1, 2, 3 ],
    '42': [ 1, 20, 3 ]
}

var keys = $.map( data, function ( element, index ) {
    return index
} );

function closest( number ) {
    var closest = null;
    $.each( keys, function () {
        if ( closest == null || Math.abs( this - number ) < Math.abs( closest - number ) ) {
            closest = this;
        }
    } );
    return closest;
}

console.log( data[closest( 16 )][1] );

感谢：最接近的功能

---

希望这有帮助。

要将其四舍五入到最接近的数字，请尝试使用以下方法：

var data = {
    '4': [ 1, 2, 3 ],
    '5': [ 1, 2, 3 ],
    '6': [ 1, 2, 3 ],
    '7': [ 1, 2, 3 ],
    '8': [ 1, 2, 3 ],
    '9': [ 1, 2, 3 ],
    '10': [ 1, 2, 3 ],
    '11': [ 1, 2, 3 ],
    '12': [ 1, 2, 3 ],
    '15': [ 1, 9, 3 ],
    '18': [ 1, 2, 3 ],
    '21': [ 1, 8, 3 ],
    '24': [ 1, 2, 3 ],
    '30': [ 1, 2, 3 ],
    '36': [ 1, 2, 3 ],
    '42': [ 1, 20, 3 ]
}

var keys = $.map( data, function ( element, index ) {
    return index
} );

function closest( number ) {
    var closest = null;
    $.each( keys, function () {
        if ( closest == null || Math.abs( this - number ) < Math.abs( closest - number ) ) {
            closest = this;
        }
    } );
    return closest;
}

console.log( data[closest( 16 )][1] );

感谢：最接近的功能

---

希望这有帮助。

我建议您使用有效的密钥

如果密钥存在，请重试，或者 获取所有键，将它们映射到数字，执行数字排序，并至少将数据减少到一个键，该键小于下一个较大的值。 “6'：[1，2，3]，“6”1，2，3，”7’：[1，2，3]，“7’：[1，2，2，3]，“7’：[1，2，2，3]，“8’：[1，2，2，3]，“4’：[4'4'4’：[1，2，2，2，3]，“4'4'4’：[1，2，2，2，3，，“7’：[1，2，2，2，2，3]，，“8'，“8’：[1，1，2，1，2，2，2，2，2，2，2，2，3]，，“8'，“8’：[1，2，2，2，2，2，2，2，2，2，3]，，，“8，，“8’：[1，1，2，2，2，2，2，2，2，2，2，2，[3]}； 函数getKeykey{ 返回数据中的键？键：Object.keysdata.mapNumber.sortfunction a，b{return a-b；}.reducefunction r，a{

---

对于我建议的有效密钥，返回一个

如果密钥存在，请重试，或者 获取所有键，将它们映射到数字，执行数字排序，并至少将数据减少到一个键，该键小于下一个较大的值。 “6'：[1，2，3]，“6”1，2，3，”7’：[1，2，3]，“7’：[1，2，2，3]，“7’：[1，2，2，3]，“8’：[1，2，2，3]，“4’：[4'4'4’：[1，2，2，2，3]，“4'4'4’：[1，2，2，2，3，，“7’：[1，2，2，2，2，3]，，“8'，“8’：[1，1，2，1，2，2，2，2，2，2，2，2，3]，，“8'，“8’：[1，2，2，2，2，2，2，2，2，2，3]，，，“8，，“8’：[1，1，2，2，2，2，2，2，2，2，2，2，[3]}； 函数getKeykey{ 返回数据中的键？键：Object.keysdata.mapNumber.sortfunction a，b{return a-b；}.reducefunction r，a{

---

如果数据结构类似于稀疏数组，则返回，并且 如果此数据结构的索引趋于更大 整数表示，然后是一种尝试和错误倒计时方法 逐步将给定的索引减少1可能不会 表现得那么好

下面的示例尝试将此考虑在内

var getNextLowerOrSameIndex = function (obj, idx) {
  var
    indexCount,
    listOfIndices
  ;
  idx = parseInt(idx, 10);

  if (!(idx in obj)) {
    listOfIndices = Object.keys(obj);

    idx = (listOfIndices.every(function (index, count/*, listOfIndices*/) {

      indexCount = count;
      index = parseInt(index, 10);

      listOfIndices[indexCount] = index;

      return (idx > index);

    }) && Math.max.apply(null, listOfIndices)) || listOfIndices[indexCount - 1];
  }
//return idx;
  return (Number.isFinite(idx) && idx) || (void 0);
};

---

如果数据结构类似于稀疏数组 如果此数据结构的索引趋于更大 整数表示，然后是一种尝试和错误倒计时方法 逐步将给定的索引减少1可能不会 表现得那么好

下面的示例尝试将此考虑在内

var getNextLowerOrSameIndex = function (obj, idx) {
  var
    indexCount,
    listOfIndices
  ;
  idx = parseInt(idx, 10);

  if (!(idx in obj)) {
    listOfIndices = Object.keys(obj);

    idx = (listOfIndices.every(function (index, count/*, listOfIndices*/) {

      indexCount = count;
      index = parseInt(index, 10);

      listOfIndices[indexCount] = index;

      return (idx > index);

    }) && Math.max.apply(null, listOfIndices)) || listOfIndices[indexCount - 1];
  }
//return idx;
  return (Number.isFinite(idx) && idx) || (void 0);
};

---

是否有任何理由使用带有数字索引的对象而不是数组？对象是如何填充的？在第一次赋值后它是否发生过更改？首先，我不是索引，它是属性名或键，如果你愿意的话。不要使用类似对象的数组。可能更谨慎的做法是询问为什么要实现下拉逻辑，以及如何使用spar在决定该数据的最佳表示形式之前，您的数据集将是。@JNF否，该对象根本不会更改。Sort object.KeyData使用一个比较函数为您排序这些索引，然后使用一个简单的搜索算法，从s的最后一个索引开始，返回等于或小于搜索值的键orted数组。你有什么理由使用带有数字索引的对象而不是数组？对象是如何填充的？在第一次赋值后它是否发生过变化？首先，我不是索引，它是属性名或键，如果你愿意的话。不要使用类似对象的数组。问一下为什么要实现下拉逻辑可能更谨慎，在决定数据的最佳表示形式之前，数据集的稀疏程度。@JNF否，对象根本不会更改。Sort object.keydata使用一个比较函数对这些索引进行排序，然后使用一个简单的搜索算法，返回与搜索值相等或更小的键，从中的最后一个开始排序数组的指数。我认为向下递增意味着递减。哈哈，是的。我的思维过程有时很奇怪。我想

---

向下递增意味着递减。哈哈，是的。我的思维过程有时很奇怪。你的第一种方法应该已经涵盖了稀疏数组的情况。Object.keys以及map和filter的实现方式将跳过数组中省略的基于索引的键。您的第一种方法应该已经涵盖了稀疏数组的情况。Object.keys以及map和filter的实现方式将跳过数组中省略的基于索引的键。