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

Question

我有一个包含这样数据的对象：

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。我该怎么做？

Answer 1

您将不得不向下循环在数组中搜索属性。假设 input 是您要查找的对象，

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

hasOwnProperty 方法检查您的数据数组是否有可用的索引，如果有，则在设置 result 后跳出循环。

Answer 2

您需要查找索引请求，如果没有找到，请从索引中减一，然后重试。类似于：

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);
    }
}

用法：

getItem(16,1);    // should give you 9

Answer 3

要将它四舍五入到最接近的以太方式，请尝试使用此方法：

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] );

感谢：最接近的函数。

希望对您有所帮助。

Answer 4

对于有效的密钥，我建议

尝试密钥是否存在，或者
获取所有键，将它们映射到Number，进行数字排序，至少将数据减少到一个键，该键小于下一个更大的值。

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] };

function getKey(key) {
    return key in data ? key : Object.keys(data).map(Number).sort(function (a, b) { return a - b; }).reduce(function (r, a) {
        return a <= key ? a : r;
    });
}

document.write('3 ' + getKey(3) + '<br>');
document.write('15 ' + getKey(15) + '<br>');
document.write('16 ' + getKey(16) + '<br>');
document.write('23 ' + getKey(23) + '<br>');
document.write('999 ' + getKey(999) + '<br>');

编辑：为了获得更好的性能，避免检查 keys 数组中的所有项目。该解决方案也适用于稀疏数组，例如

var data = [];
data[4] = [1, 2, 3];
data[5] = [1, 2, 3];
data[6] = [1, 2, 3];

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] },
    keys = Object.keys(data).map(Number).sort(function (a, b) { return a - b; }),
    i;

function getKey(key) {
    var lower = 0,
        upper = keys.length - 1,
        index;

    if (key in data) {
        return key;
    }
    if (key < keys[0]) {
        return; // this is not specified in question
    }
    if (key > keys[upper]) {
        return keys[upper];
    }
    while (lower !== upper) {
        index = lower + upper >> 1;
        if (key > keys[index]) {
            lower = index + 1;
            continue;
        }
        upper = index;
    }
    return keys[lower - 1];
}

for (i = -5; i < 50; i++) {
    document.write('value: '+ i + ', key: ' + getKey(i) + '<br>');
}

Answer 5

如果数据结构类似于稀疏数组并且如果这个数据结构的索引往往更大整数代表，然后一个"try-and-error count-down approach" 逐步将给定索引减少 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);
};

...

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]
};

console.log(data[getNextLowerOrSameIndex(data, 4)][1]);     // 2
console.log(data[getNextLowerOrSameIndex(data, "4")][1]);   // 2
console.log(data[getNextLowerOrSameIndex(data, "5")][1]);   // 2

console.log(data[getNextLowerOrSameIndex(data, 15)][1]);    // 9
console.log(data[getNextLowerOrSameIndex(data, 16)][1]);    // 9
console.log(data[getNextLowerOrSameIndex(data, "15")][1]);  // 9
console.log(data[getNextLowerOrSameIndex(data, "17")][1]);  // 9

console.log(data[getNextLowerOrSameIndex(data, "23")][1]);  // 8
console.log(data[getNextLowerOrSameIndex(data, 999)][1]);   // 20

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

Get data in object if index doesn't exist

javascript

algorithm

performance

data-structures

javascript-objects