Question

帮我写一个对对象进行排序的函数：

我有一个类似的对象，它将根据其在“ order”中的键进行排序：

var users = {
  certificate:'certificate of student',
  lessons:  {
        lession_1: { 'user': 'fred',   'order': 1 },
        lession_2: { 'user': 'barney', 'order': 2 },
        lession_4: { 'user': 'fred',   'order': 4 },
        lession_3: { 'user': 'barney', 'order': 3 }
    }
};

应该在排序之后：

var users = {
  certificate:'certificate of student',
  lessons:  {
        lession_1: { 'user': 'fred',   'order': 1 },
        lession_2: { 'user': 'barney', 'order': 2 },
        lession_3: { 'user': 'barney', 'order': 3 },
        lession_4: { 'user': 'fred',   'order': 4 }
    }
};

Answer 1

首先，您需要将课程对象转换为数组，因为sort仅适用于 Array 。

const arrayLessons = Object.values(users.lessons);
现在使用sort对arrayLessons进行排序。

const sortedArray = arrayLessons.sort((prev, next) => prev.order - next.order);
为用户
的对象更新数据
users.lessons = sortedArray;

Answer 2

由于无法对对象的键进行排序，因此必须：

将对象转换为数组。
排序数组。
转换数组回到一个对象。

这是一种有效的方法：

var users = {
  certificate:'certificate of student',
  lessons:  {
        lession_1: { 'user': 'fred',   'order': 1 },
        lession_2: { 'user': 'barney', 'order': 2 },
        lession_4: { 'user': 'fred',   'order': 4 },
        lession_3: { 'user': 'barney', 'order': 3 }
   }
}; 

function sortLessons (obj) {
    obj.lessons = Object.entries(obj.lessons)
        .sort((prev, next) => prev[1].order - next[1].order)
        .reduce((acc, value) => {
            acc[value[0]] = value[1];
            return acc;
        }, {});
}

sortLessons(users);

console.log(users);

Object.entries为每个条目返回一个数组[key, value]。

然后sort函数使用一个compareFunction，documentation说：

如果compareFunction(a, b)返回的值大于0，则将b排序为小于a的索引（即b排在最前面）。

通过进行差异a - b，在您的情况下，4-3 = 1，lesson_3将插入lesson_4的前面，并对数组进行排序。

然后，reduce函数将重建对象。

Answer 3

非符号属性are now determined by insertion order的键顺序（从ES6开始）。考虑到这一点，您可以提取lesson对象的值，然后使用.sort()对对象数组中的每个对象进行排序。然后，您可以遍历排序后的数组并将对象按在排序后的.lessons数组中出现的顺序插入新的order对象，如下所示：

const users = {
  certificate: 'certificate of student',
  lessons: {
    lession_1: {
      'user': 'fred',
      'order': 1
    },
    lession_2: {
      'user': 'barney',
      'order': 2
    },
    lession_4: {
      'user': 'fred',
      'order': 4
    },
    lession_3: {
      'user': 'barney',
      'order': 3
    }
  }
};

const sortObj = (obj) => {
  const order = Object.entries(obj.lessons).sort(([,a], [,b]) => a.order-b.order);
  obj.lessons = {};
  for(const [lesson, user] of order)
    obj.lessons[lesson] = user;

}

sortObj(users)
console.log(users);

但是，我建议您倾向于使用数组而不是对象，因为您将要对对象进行排序，因为它更加直观：

const users = {
  certificate: 'certificate of student',
  lessons: [
    {
      'user': 'fred',
      'order': 1
    },
    {
      'user': 'barney',
      'order': 2
    },
    {
      'user': 'fred',
      'order': 4
    },
    {
      'user': 'barney',
      'order': 3
    }
  ]
};

const sortObj = (obj) => {
  obj.lessons.sort((a, b) => a.order-b.order);
}

sortObj(users)
console.log(users);

Answer 4

尝试以下操作：-

var users = {
  certificate:'certificate of student',
  lessons:  {
        lession_1: { 'user': 'fred',   'order': 1 },
        lession_2: { 'user': 'barney', 'order': 2 },
        lession_4: { 'user': 'fred',   'order': 4 },
        lession_3: { 'user': 'barney', 'order': 3 }
    }
}; 

keysSorted = Object.keys(users.lessons).sort(function(a,b){return users.lessons[a]['order']-users.lessons[b]['order']})   //get sorted keys

let sortedLessons={};

for(let key of keysSorted){
   sortedLessons[key]=users.lessons[key];
}

users.lessons=sortedLessons;
console.log(users)

根据对象内部的键对对象进行排序

4 个答案: