Question

为了更好地理解如何操作对象，我试图根据对象的值对对象进行排序。

例如

let obj = {
    1: 5,
    2: 4,
    3: 200,
    4: 3,
    5: 1
}

我想要输出

{
    3: 200,
    1: 5,
    2: 4,
    4: 3,
    5: 1
}

我遍历了该对象，并将其键值对添加到一个新数组中，然后按值对它们进行排序。

新数组看起来像这样

[
    [3, 200],
    [1, 5],
    [2, 4],
    [4, 3],
    [5, 1]
]

然后我遍历此数组并从中创建一个新对象，但它以

的形式出现

{ 1: 5, 2: 4, 3: 200, 4: 3, 5: 1 }

为什么？

let obj = {
  1: 5,
  2: 4,
  3: 200,
  4: 3,
  5: 1
}

const sortObj = o => {
  const arr = [];
  const _obj = {};

  for (const v in o) arr.push([v, o[v]]);

  arr.sort((a, b) => b[1] - a[1]);

  for (const v of arr) {
    console.log(v);
    /*
    [
      [3, 200],
      [1, 5],
      [2, 4],
      [4, 3],
      [5, 1]
    ]
    */
    const [key, val] = v;
    console.log(key, val);
    _obj[key] = val;
  }

  return _obj;
}

console.log(sortObj(obj));

Answer 1

从ES2015开始，您的对象键将几乎始终保留其插入顺序。但是，为数不多的例外之一是您的键是整数。

以下示例显示，当我们改用string键时，排序工作正常...

let obj = {
  test: 5,
  this: 4,
  out: 200,
  and: 3,
  see: 1
}

const sortObj = o => {
  const arr = [];
  const _obj = {};

  for (const v in o) arr.push([v, o[v]]);

  arr.sort((a, b) => b[1] - a[1]);

  for (const v of arr) {
    const [key, val] = v;
    _obj[key] = val;
  }

  return _obj;
}

console.log(sortObj(obj));

或者，使用Map代替，总是保留顺序。

let obj = {
  1: 5,
  2: 4,
  3: 200,
  4: 3,
  5: 1
}

const sortObj = o => {
  const arr = [];
  const _obj = new Map();

  for (const v in o) arr.push([v, o[v]]);

  arr.sort((a, b) => b[1] - a[1]);

  for (const v of arr) {
    const [key, val] = v;
    _obj.set(key, val);
  }

  return _obj;
}

var sortedMap = sortObj(obj);
sortedMap.forEach((val, key) => console.log(`${key}: ${val}`));

Answer 2

好吧，上面已经有一个有效的答案，但是由于我已经开始尝试订购并且版本短一些，因此发布的答案不正确。

相关阅读： Does JavaScript Guarantee Object Property Order?

let obj = {
    1: 5,
    2: 4,
    3: 200,
    4: 3,
    5: 1
}
sortedObj = Object.keys(obj).sort((key1, key2) => {
    if (obj[key1] > obj[key2]) {return -1;}
    if (obj[key1] < obj[key2]) {return 1;}
    return 0;
}).reduce((acc, key) => {
    acc['i_'+key] = obj[key];
    return acc;
}, {});

Answer 3

如果可以的话，请使用Map，它会保留我上面评论中提到的顺序。使用Map的好处是，您的密钥不会转换为字符串，它也可以保留类型。

let obj = {
  1: 5,
  2: 4,
  3: 200,
  4: 3,
  5: 1
}

const sortObj = o => {
  const arr = [];
  const map = new Map();

  for (const v in o) arr.push([v, o[v]]);

  arr.sort((a, b) => b[1] - a[1]);

  for (const v of arr) {
    console.log(v);
    /*
    [
      [3, 200],
      [1, 5],
      [2, 4],
      [4, 3],
      [5, 1]
    ]
    */
    const [key, val] = v;
    //console.log(key, val);
    map.set(key,val);
  }

  return map;
}
sortObj(obj).forEach((k,v)=>console.log(v,k))

通过对象的值对对象中的值进行排序-js

3 个答案: