Question

我有一个带有类的数组（该类称为Note），在这些类中是基本值。两个重要的值是Note.Pinned（布尔值是否固定）和Note.Modified（上次编辑的时间戳记）。

我想按Modified时间戳对该类数组进行排序，然后重新排序，使Pinned注释位于此列表的顶部。

我已经尝试对笔记进行排序。

const SortedNotes = Notes.sort((a, b) => a.Modified > b.Modified);

Notes是具有类的数组。

但是，有没有更好的方法可以重新排列此数组？还是这是我唯一可以使用的方法？

SortedNotes.filter(n => n.Pinned).concat(SortedNotes.filter(n => !n.Pinned));

上面的方法可行，我知道我可以使用Array.prototype.partition，所以还有其他方法吗？

谢谢

Answer 1

您只需将固定排序要求添加到排序：

const arr = [{
    pinned: false,
    modified: 7
  },
  {
    pinned: false,
    modified: 6
  },
  {
    pinned: true,
    modified: 2
  },
  {
    pinned: false,
    modified: 4
  },
  {
    pinned: true,
    modified: 1
  },
  {
    pinned: true,
    modified: 8
  },
  {
    pinned: false,
    modified: 3
  },
]

arr.sort((a, b) => {
  if (a.pinned != b.pinned)
    return a.pinned ? -1 : 1;
  return b.modified - a.modified;
})

console.log(arr)

只要对相同的两个给定参数执行sort函数返回相同的结果，排序就可以正常工作。知道了这一点，您可以处理固定状态不同的两个状态，然后仅在固定状态相同的情况下按修改后的顺序进行排序。

Answer 2

也许不是最好的解决方案，但这应该可以在正确的方向上为您提供帮助。这样可以对数组进行排序，以便便笺按降序排列，固定的注释在顶部。

与其他（更好的）答案不同，它具有O（2n）的排序复杂度，因此请记住这一点。

const notes = [
  {
    text: "foo",
    modified: 1583337610387,
    pinned: false
  },
  {
    text: "bar",
    modified: 1583337610388,
    pinned: true
  },
  {
    text: "baz",
    modified: 1583337610389,
    pinned: false
  },
  {
    text: "qux",
    modified: 1583337610390,
    pinned: true
  }
];

const sortedNotes = [...notes];
sortedNotes.sort((a, b) => a.modified > b.modified ? -1 : 1);
sortedNotes.sort((a, b) => (a.pinned === b.pinned) ? 0 : a.pinned ? -1 : 1);
console.log(sortedNotes);

Answer 3

您可以按多种条件进行排序：

const SortedNotes = Notes.sort((a, b) => {
  if (a.Pinned == b.Pinned) {
    if (a.Modified > b.Modified) return -1;
    if (a.Modified < b.Modified) return 1;
  } else {
    return a.Pinned ? -1 : 1;
  }
});

a.Pinned == b.Pinned && a.Modified == b.Modified的丢失分支将返回undefined，而后者将被解释为相等。

顺便说一句，数组Notes本身已经被修改了，因此SortedNotes和Notes都将显示相同的顺序；当然，分配给const变量不会有问题。

Answer 4

Shorter，您可以尝试

const SortedNotes = Notes.sort((a, b) => {
    if (a.Pinned > b.Pinned)
       return 1;
    if (a.Pinned == b.Pinned) 
       return a.Modified > b.Modified;
    return -1;
})

Answer 5

我编辑了@Ja͢ck的答案，使其更加紧凑。

const SortedNotes = Notes.sort((a, b) => {
    if (a.Pinned == b.Pinned) return a.Modified > b.Modified ? -1 : 1;
    else return a.Pinned ? -1 : 1;
});

根据值对数组重新排序

5 个答案: