25

给定一个键，我想在一个对象中找到下一个属性。我不能依赖要排序或顺序的键（它们是 uuid）。请参阅下面的我想要的简单示例：

var db = {
  a: 1,
  b: 2,
  c: 3
}

var next = function(db, key) {
  // ???
}

next(db, 'a');  // I want 2
next(db, 'b');  // I want 3

我也想要一个 prev() 函数，但我相信它会是相同的解决方案。

这似乎是一个微不足道的问题，但我一生都无法弄清楚如何去做。

很高兴使用 underscore.js 或用咖啡脚本编写的解决方案 :)

4

6 回答 6

24

ts/es6 版本。我只是从 storeObject 中获取键，查找下一个索引。 

 let keys = Object.keys(storeObject);
 let nextIndex = keys.indexOf(theCurrentItem) +1;
 let nextItem = keys[nextIndex];
于 2017-10-25T22:26:22.927 回答
22

正确的答案是：你不能这样做，因为对象按照 ECMAScript 的规范是无序的。

我建议您使用有序结构（如数组）来解决问题：

var db = [
  {key: 'a', value: 1},
  {key: 'b', value: 2},
  {key: 'c', value: 3}
];

那么next函数可以是这样的：

var next = function(db, key) {
  for (var i = 0; i < db.length; i++) {
    if (db[i].key === key) {
      return db[i + 1] && db[i + 1].value;
    }
  }
};

如果key不存在db或它是最后一个，则next返回undefined。如果您永远不会要求最后一项的下一项，您可以通过删除三元&&运算符并db[i + 1].value直接返回来简化该功能。

您还可以使用一些 Underscore.js 实用方法来next简化：

var next = function(db, key) {
  var i = _.pluck(db, 'key').indexOf(key);
  return i !== -1 && db[i + 1] && db[i + 1].value;
};

（在这种情况下有时next可能会返回false......但它仍然是一个虚假值:)）

现在，一个更务实的答案可能是，因为大多数浏览器在迭代对象时都会尊重对象的初始化顺序，因此您可以for in按照其他答案的建议使用循环对其进行迭代。我建议使用Object.keys来简化遍历数组的工作：

// Assuming that db is an object as defined in the question.
var next = function(db, key) {
  var keys = Object.keys(db)
    , i = keys.indexOf(key);
  return i !== -1 && keys[i + 1] && db[keys[i + 1]];
};
于 2012-09-20T04:10:00.210 回答
6 
function next(db, key){   
  var found = 0; 
  for(var k in db){
    if(found){ return db[k]; }
    if(k == key){ found = 1; }
  }
}
于 2012-09-20T03:24:24.770 回答
5

对此的直接解决方案是将数据存储在一个数组中，并使用该对象简单地将索引存储在对象所在的数组中。

var db = {
    data: [1, 2, 3],
    index: {
        a: 0,
        b: 1,
        c: 2
    }
};
function next(db, key) {
    var next = db.index[key] + 1;
    if (next >= db.data.length) {
        return null;
    }
    return db.data[next];
}
function prev(db, key) {
    var next = db.index[key] - 1;
    if (next < 0) {
        return null;
    }
    return db.data[next];
}
function add(db, key, value) {
    db.index[key] = db.data.push(value) - 1;
}
function remove(db, key) {
    var index = db.index[key], x, temp;
    if (index !== undefined) {
        delete db.index[key];
        db.data.splice(index, 1);
        // Update indices of any elements after the removed element
        for (x in db.index) {
            temp = db.index[x];
            if (temp > index) {
                db.index[x] = temp - 1;
            }
        }
    }
}

基本思想是使用有序结构（在本例中为数组）以顺序方式保存数据。在这种情况下，next 和 prev 都是常数时间，add 是摊销常数时间，delete 是 O(N)。

ECMA 标准不保证键的顺序，因此for/in不需要按照添加键的顺序（尽管在实践中，这往往是常见的实现）。在这个解决方案中，我使用一个数组来显式地跟踪插入顺序。

编辑：我之前忽略了拼接的删除问题。删除拼接值后，所有值的索引都会变得不正确。该修复不会影响操作的运行时间复杂度。具有较少删除的更快版本可以让数组变得稀疏，而不是拼接，只需将索引设置为 null 以释放存储在那里的任何引用。这会将删除操作降低到 O(1)。

function remove(db, key) {
    var index = db.index[key];
    if (index !== undefined) {
        delete db.index[key];
        db.data[index] = null;
    }
}
于 2012-09-20T03:19:17.857 回答
3

使用 undercore.js，您可以获取对象的键并完成任务。但我不确定键值对是否以任何方式排序：

var next = function(db, key) {
    var keys = _.keys(db);
    var index = _.indexOf(keys, key);
    if(index+1<keys.length){
         return db[keys[index+1]];
    }else{
        return null;
    }
}

jsFiddle：http: //jsfiddle.net/QWhN2/

于 2012-09-20T03:18:20.160 回答
0

我在 2021 年来到这里，所以我将发布一个 Es6 解决方案。

一个简单的解决方案，可让您在给定起始键的情况下导航对象：

const navObj = (obj, currentKey, direction) => {
    return Object.values(obj)[Object.keys(obj).indexOf(currentKey) + direction];
};

const db = {
  a: 1,
  b: 2,
  c: 3
};

console.log(navObj(db, 'a', 1));
console.log(navObj(db, 'a', 2));
console.log(navObj(db, 'b', -1));
于 2021-01-14T17:22:42.560 回答