Javascript 如果键是重复的，则替换项目并排序和删除，除了最后 2 个项目

Question

我有如下数组，我想按键排序，然后删除除最后两项之外的所有内容并删除剩余的。

var status = new Array();
status.push({key: 'BOB', value: 10});
status.push({key: 'TOM', value: 3});
status.push({key: 'ROB', value: 22});
status.push({key: 'JON', value: 7});

如果我再次用重复键按下下面：

status.push({key: 'BOB', value: 20});

我需要以下输出，如何在 javascript 中实现。

[
  {
    "key": "BOB",
    "value": 20
  },
  {
    "key": "TOM",
    "value": 3
  },
  {
    "key": "ROB",
    "value": 22
  },
  {
    "key": "JON",
    "value": 7
  }
]

注意：我需要稍后按键排序。

编辑：如果我有这样的对象，我如何按键排序？并只获取​​最后 2 个项目并删除剩余的项目。

var status = new Object();
status['BOB'] = 10
status['TOM'] = 3
status['ROB'] = 22
status['JON'] = 7

Answer 1

我会使用Map 而不是数组或对象。地图就像对象but with some important differences。

// initialize the map
var stats = new Map([['BOB',10],['TOM',3],['ROB',22],['JON',7]]);
// set a specific key's value
stats.set('BOB', 20);
// sort by key
var keys = Array.from(stats.keys());
keys.sort();
// get the last two
keys = keys.slice(-2);
// map the remaining keys to the desired structure
var result = keys.map(key => { 
  return { 
    key: key, 
    value: stats.get(key) 
  }; 
});
console.log(result);

Answer 2

不要使用数组，而是使用对象：

(function () {
  var status = {};
  status['BOB'] = 10;
  status['TOM'] = 3;
  status['ROB'] = 22;
  status['JON'] = 7;
  status['BOB'] = 20;
  // convert to array
  var output = Object.keys(status)
    // sort by key
    .sort()
    // keep last two after sorting
    .slice(-2)
    // convert [key, value] to { key, value }
    .map(function (key) {
      return { key: key, value: status[key] };
    });

  console.log(output);
})();

.as-console-wrapper{max-height:100%!important}

Answer 3

如果您决定保留对象数组结构，您可以使用Array.findIndex() 和Array.splice() 以这种方式实现一个方法：

const pushWithCheck = (arr, obj) =>
{
    let idx = arr.findIndex(({key}) => key === obj.key);

    if (idx >= 0)
        arr.splice(idx, 1, obj);
    else
        arr.push(obj);
}

var _status = [];
pushWithCheck(_status, {key: 'BOB', value: 10});
pushWithCheck(_status, {key: 'TOM', value: 3});
pushWithCheck(_status, {key: 'ROB', value: 22});
pushWithCheck(_status, {key: 'JON', value: 7});
console.log("Before duplicated key:", _status);
pushWithCheck(_status, {key: 'BOB', value: 20});
pushWithCheck(_status, {key: 'ROB', value: 99});
console.log("After duplicated key:", _status);

.as-console {background-color:black !important; color:lime;}
.as-console-wrapper {max-height:100% !important; top:0;}

现在，要按对象的 key 属性排序并获取最后一个 2 元素，您可以将 Array.sort() 和 Array.slice() 与否定 (-2) 参数一起使用，如下所示：

const pushWithCheck = (arr, obj) =>
{
    let idx = arr.findIndex(({key}) => key === obj.key);

    if (idx >= 0)
        arr.splice(idx, 1, obj);
    else
        arr.push(obj);
}

// Generate the _status array.
var _status = [];
pushWithCheck(_status, {key: 'BOB', value: 10});
pushWithCheck(_status, {key: 'TOM', value: 3});
pushWithCheck(_status, {key: 'ROB', value: 22});
pushWithCheck(_status, {key: 'JON', value: 7});
pushWithCheck(_status, {key: 'BOB', value: 20});
pushWithCheck(_status, {key: 'ROB', value: 99});
console.log("_status is: ", _status);

// Sort the _status array by ascending.
let sorted = _status.slice().sort((a, b) => a.key.localeCompare(b.key));

// Get last two elements of the sorted array.
let lastTwo = sorted.slice(-2);

console.log("Sorted is: ", sorted);
console.log("Last two elements are: ", lastTwo);

.as-console {background-color:black !important; color:lime;}
.as-console-wrapper {max-height:100% !important; top:0;}

Answer 4

如果您想按照其他人建议的方式进行操作，您应该使用 set 集合中始终包含唯一元素

// initialize the map
var stats = new Set([['BOB',10],['TOM',3],['ROB',22],['JON',7]]);
// set a specific key's value
stats.add('BOB', 20);
// sort by key
var keys = Array.from(stats.keys());
keys.sort();
// get the last two
keys = keys.slice(-2);
// map the remaining keys to the desired structure
var result = keys
console.log(result);

我认为这回答了你所有的问题

let status1 = [];
status1.push({
    key: 'BOB',
    value: 10
}, {
    key: 'TOM',
    value: 3
}, {
    key: 'ROB',
    value: 22
}, {
    key: 'JON',
    value: 7
});

console.log('Initial array', status1);

//const newItem = {
//  key: 'BOB',
//  value: 20
//};

const newItem = {
    key: 'BOB',
    value: 99
};

for (let i = 0; i < status1.length; i++) {

    if (status1[i].key === newItem.key) {
        status1[i] = newItem;
    }

}

Array.prototype.inArray = function(comparer) { 
    for(var i=0; i < this.length; i++) { 
        if(comparer(this[i])) return true; 
    }
    return false; 
}; 
Array.prototype.pushIfNotExist = function(element, comparer) { 
    if (!this.inArray(comparer)) {
        this.push(element);
    }
}; 

//https://stackoverflow.com/questions/1988349/array-push-if-does-not-exist 

status1.pushIfNotExist(newItem, function(e) { 
    return e.key === newItem.key; 
});

console.log('after push', status1);

function sortByKey(array, key) {
    return array.sort(function (a, b) {
        var x = a[key];
        var y = b[key];
        return ((x < y) ? -1 : ((x > y) ? 1 : 0));
    });
}

sortByKey(status1, 'key');
console.log('AFter sort', status1);

console.log('Last item', status1[status1.length - 1]);
console.log('Second Last item', status1[status1.length - 2]);