您可以获取条目，对它们进行排序和切片，然后通过将Map对象分配给单个对象来构建新对象。

var object = { t1: 1, t2: 33, t3: 10, t4: 9, t5: 45, t6: 101 },
    result = Object.assign(                      // collect all objects into a single obj
        ...Object                                // spread the final array as parameters
            .entries(object)                     // key a list of key/ value pairs
            .sort(({ 1: a }, { 1: b }) => b - a) // sort DESC by index 1
            .slice(0, 3)                         // get first three items of array
            .map(([k, v]) => ({ [k]: v }))       // map an object with a destructured
    );                                           // key/value pair

console.log(result);

可以将对象而不是值推入数组，以便存储键

var obj = {
    t1: 1,
    t2: 33,
    t3: 10,
    t4: 9,
    t5: 45,
    t6: 101
}

// create an array
var arr = [];

// loop through the object and add values to the array
for (var p in obj) {
  arr.push({key: p, value: obj[p]});
}

// sort the array, largest numbers to lowest
arr.sort(function(a,b){return b.value - a.value});

// grab the first 10 numbers
var firstThree = arr.slice(0, 3);
console.log(firstThree);

可以将包含键和值关联arr.push({p: obj[p]})的对象推送到数组中

var obj = {
  t1: 1,
  t2: 33,
  t3: 10,
  t4: 9,
  t5: 45,
  t6: 101
}

// create an array
var arr = [];

// loop through the object and add values to the array
for (var p in obj) {
  arr.push({
    p: obj[p]
  });
}

// sort the array, largest numbers to lowest
arr.sort(function(a, b) {
  return b - a
});

// grab the first 10 numbers
var firstThree = arr.slice(0, 3);
console.log(firstThree);

没有什么花哨的，但做的工作：-）

你可以做这样的事情

var obj = {
  t1: 1,
  t2: 33,
  t3: 10,
  t4: 9,
  t5: 45,
  t6: 101
};

// create an array
var arr = [];

// loop through the object and add values to the array
for (var p in obj) {
  arr.push({ key: p, val: obj[p] });
}

// sort the array, largest numbers to lowest
arr.sort(function(a, b) {
  return b.val - a.val;
});

// grab the first 10 numbers
var firstThree = arr.slice(0, 3);
console.log(...firstThree);

你可以先得到这个对象的值并排序，然后使用Object.entries()循环到这个对象的key-value，并确定这个值的键属于前3个值：

var obj = {
    t1: 1,
    t2: 33,
    t3: 10,
    t4: 9,
    t5: 45,
    t6: 101
};

var values = Object.values(obj).sort((a,b) => b-a).slice(0,3);
let resultObj = {};
Object.entries(obj).forEach((item) => {
  if(values.indexOf(item[1]) !== -1){
    resultObj[item[0]] = item[1];
  }
});
console.log(resultObj);

还要注意，在使用object时，object中的键顺序实际上并不重要，因此

{
    t6: 101,
    t5: 45,
    t2: 33

}

类似于

{
    t2: 33,
    t5: 45,
    t6: 101

}

使用lodash的替代解决方案

_.chain(object)
    .map((value, key) => ({value, key}))
    .sortBy("value")
    .reverse()
    .take(3)
    .reduce((acc, item) => ({ ...acc, [item.key]: item.value}), {})
    .value();

var obj = {
  t1: 1,
  t2: 33,
  t3: 10,
  t4: 9,
  t5: 45,
  t6: 101
};

const sortedKey = Object.keys(obj).sort((a,b)=>{
if(obj[a] > obj[b]) return -1;
if(obj[a] < obj[b]) return 1;
return 0;
})
//print top three key -- val
for(let i=0; i< 3; i++) console.log(sortedKey[i], '--', obj[sortedKey[i]])

对象的键不能保证保持顺序，所以不要相信它。
不过，创建并使用一个数组是安全的：

const top10KeyValArr = Object.entries(obj).sort(([_k1, val1], [_k2, val2])=> val2 - val1).slice(0, 3);

然后你可以对它做你想做的事情，它会保持那个顺序。