Sorting 按值对对象进行Lodash排序，而不会丢失键

假设我有一个对象：

{Derp: 17, Herp: 2, Asd: 5, Foo: 8, Qwe: 12}

我需要按值排序。我希望得到的是：

{Derp: 17, Qwe: 12, Foo: 8, Asd: 5, Herp: 2}

我想用lodash。当我使用

\时，sortBy

不会保留钥匙，但：

_.sortBy({Derp: 17, Herp: 2, Asd: 5, Foo: 8, Qwe: 12}).reverse();
// [17, 12, 8, 5, 2]

见鬼，我甚至只接受键数组，但仍然按输入中的值排序：

['Derp', 'Herp', 'Foo', 'Asd', 'Qwe']

---

你可以这样试试

_.mapValues(_.invert(_.invert(obj)),parseInt);

对象{Herp:2，Asd:5，Foo:8，Qwe:12，Derp:17}

或

对象{Derp:17，Qwe:12，Foo:8，Asd:5，Herp:2}

或 使用链方法：

_.chain(obj).invert().invert().reduceRight(function(current, val, key){ 
    current[key] = parseInt(val);
    return current;
},{}).value()

对象{Derp:17，Qwe:12，Foo:8，Asd:5，Herp:2}

---

注意：这取决于浏览器通常情况下对象属性顺序在大多数情况下不是gurrantee。

我也遇到过类似的问题，通过使用lodash进行一些转换，我能够解决这个问题。对于您的问题，可能是：

let doo = {Derp: 17, Herp: 2, Asd: 5, Foo: 8, Qwe: 12};

let foo = _.chain(doo)
  .map((val, key) => {
    return { name: key, count: val }
  })
  .sortBy('count')
  .reverse()
  .keyBy('name')
  .mapValues('count')
  .value();

console.log(foo);
// Derp: 17, Qwe: 12, Foo: 8, Asd: 5, Herp: 2 }

这对我有用

o = _.fromPairs(_.sortBy(_.toPairs(o), 1).reverse())

下面是一个例子：

var o={
答:2,，
c:3，
b:1
};
o=u.fromPairs（u.sortBy（u.toPairs（o），1.reverse（））
控制台日志（o）
香草ES6版本

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

const sorted = Object.entries(obj)
  .sort((a, b) => a[1] <= b[1] ? -1 : 1)
  .reduce((acc, pair) => {
    acc[pair[0]] = pair[1]
    return acc
  }, {})

// Output: { b: 1, a: 2, c: 3 }

const obj={
答:2,，
c:3，
b:1
}
const sorted=Object.entries（obj）
.sort（（a，b）=>a[1]{
acc[对[0]]=对[1]
返回acc
}, {})
//输出：{b:1，a:2，c:3}

这还允许您访问排序回调，允许对更深层的对象属性进行更细粒度的排序。
如果您有非唯一值，则此操作将失败：p，生成的objectheads中只会有一个非唯一值，这对我不起作用，我必须使用frankies代替。您可能需要更新版本的lodash？举例说明它是如何不起作用的。请记住，原始问题的作者希望值按降序排序。如果您想让它们升序，只需删除.reverse（），我认为这应该是正确的答案。正如当前正确答案的顶部评论员所说，如果对象中有非唯一值，该解决方案将销毁具有类似值的属性。没有按照建议工作，但工作方式如下o=.sortBy（.toPairs（o），1）.reverse（）此解决方案最适合我，因为即使存在非唯一值，它也能工作。如果您的名称字段是一个数字，此解决方案将不适用于您（尚未找到一个可以），但这是很好的选择
const obj = {
  a: 2,
  c: 3,
  b: 1
}

const sorted = Object.entries(obj)
  .sort((a, b) => a[1] <= b[1] ? -1 : 1)
  .reduce((acc, pair) => {
    acc[pair[0]] = pair[1]
    return acc
  }, {})

// Output: { b: 1, a: 2, c: 3 }