对象中的顶级值，用键显示，javascript

但是，我能够成功地找到对象中的最大值。存在一个问题，即无法显示具有该值的关联键

var obj={
t1:1，
t2:33，
t3:10，
t4:9，
t5:45，
t6:101
//...
}
//创建一个数组
var-arr=[]；
//循环遍历对象并向数组中添加值
用于（obj中的var p）{
arr.push（obj[p]）；
}
//对数组进行排序，从最大值到最小值
sort（函数（a，b）{返回b-a}）；
//抓住前10个数字
var firstThree=arr.slice（0,3）；
console.log（前三个）您可以将对象而不是值推入数组，以便存储键


var obj={
t1:1，
t2:33，
t3:10，
t4:9，
t5:45，
t6:101
}
//创建一个数组
var-arr=[]；
//循环遍历对象并向数组中添加值
用于（obj中的var p）{
arr.push（{key:p，value:obj[p]}）；
}
//对数组进行排序，从最大值到最小值
arr.sort（函数（a，b）{返回b.value-a.value}）；
//抓住前10个数字
var firstThree=arr.slice（0,3）；
console.log（前三个）
您可以将包含键和值关联的对象推送到数组中
arr.push（{p:obj[p]}）


var obj={
t1:1，
t2:33，
t3:10，
t4:9，
t5:45，
t6:101
}
//创建一个数组
var-arr=[]；
//循环遍历对象并向数组中添加值
用于（obj中的var p）{
arr.push({
p:obj[p]
});
}
//对数组进行排序，从最大值到最小值
arr.sort（函数（a，b）{
返回b-a
});
//抓住前10个数字
var firstThree=arr.slice（0,3）；
console.log（前三个）您可以获取条目，对它们进行排序和切片，并通过将映射对象指定给单个对象来构建新对象


var对象={t1:1，t2:33，t3:10，t4:9，t5:45，t6:101}，
结果=对象。分配（//将所有对象收集到单个对象中
…对象//将最终数组作为参数展开
.entries（object）//为键/值对列表设置键
.sort（（{1:a}，{1:b}）=>b-a）//按索引1对DESC进行排序
.slice（0，3）//获取数组的前三项
.map（（[k，v]）=>（{[k]：v}））//将对象映射到已解构的
);                                           // 键/值对
控制台日志（结果）您可以这样做

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（）
循环到该对象的键值，并确定属于前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）；
设resultObj={}；
Object.entries（obj.forEach）（（项）=>{
如果（值.indexOf（项目[1]）！=-1）{
结果j[项目[0]]=项目[1]；
}
});
console.log（resultObj）
var obj={
t1:1，
t2:33，
t3:10，
t4:9，
t5:45，
t6:101
};
const sortedKey=Object.key（obj.sort）（a，b）=>{
if（obj[a]>obj[b]）返回-1；
if（obj[a]
使用
lodash的替代解决方案

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

你是否需要
result
成为与
obj
相同的对象（删除其他键），或者是一个全新的对象（因此，你现在有两个）？无论什么是最有效的方法，都是im追求的方法，我只想发送和对象具有最高值和相关键，并且可能具有不完全相同的副本，我认为这里更简单，更灵活，即使有注释也很难理解，但它是有效的，我试着坐在它旁边玩console.log，但仍然没有真正了解它的工作原理，比如为什么sort有{1:a}，{1:b}。这是一个包含两个参数的数组，其中，数组被分解为具有键
1
的对象，并重命名为
a
或
b
。对于单个数组，它看起来像
['t6'，101]
，结果是
101
。啊，现在它有意义了。我知道销毁赋值，但以前只在数组或导入中使用过：）谢谢尼娜
_.chain(object)
    .map((value, key) => ({value, key}))
    .sortBy("value")
    .reverse()
    .take(3)
    .reduce((acc, item) => ({ ...acc, [item.key]: item.value}), {})
    .value();