如何根据几个参数对数组进行排序？

Question

把玩网络游戏当作业余爱好。我有一个“清单”，里面有宠物：

interface Pet {
  type: string;
  level: number;
  isFavorite: boolean;
}

allPetSlots = [
  {slotState: INVENTORY_STATE.EQUIPPED, pet: {...},
  {slotState: INVENTORY_STATE.OCCUPIED, pet: {...},
  {slotState: INVENTORY_STATE.OCCUPIED, pet: {...},
  {slotState: INVENTORY_STATE.EMPTY, pet: null,
  {slotState: INVENTORY_STATE.EMPTY, pet: null,
  {slotState: INVENTORY_STATE.EMPTY, pet: null,
  {...}
]

我目前有一个sortAll方法，可以根据这些特定标准对库存进行排序：

1. 收藏宠物显示第一个
2. 组，按PET类型，
3. ，按级别顺序排列，
4. ，在

G 211之后出现所有空白点

这就是我所拥有的：

allPetsSlots
        .sort((a) => (a.state === 'occupied' || a.state === 'equipped' ? -1 : 1))
        .sort((a, b) => {
            if (a.pet?.type < b.pet?.type) return -1;
            if (a.pet?.type > b.pet?.type) return 1;
            return 0;
        })
        .sort((a, b) => {
            if (a.pet?.type === b.pet?.type && a.pet?.level > b.pet?.level) return -1;
            if (a.pet?.type === b.pet?.type && a.pet?.level < b.pet?.level) return 1;
            return 0;
        })
        .sort((a, b) => {
            if (a.pet?.isFavorite || b.pet?.isFavorite) return -1;
            return 1;
        })

虽然这个似乎可以在中工作：

​

我在其他浏览器上遇到了一些麻烦。我很肯定我的分类功能正在做一些奇怪的事情，我的大脑今天特别模糊。

会很感激你的帮助！

​

const currentPets = [
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'occupied', pet: { type: 'quartz', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'quartz', level: 3, isFavorite: false}},
  { state: 'equipped', pet: { type: 'quartz', level: 6, isFavorite: true}},
  { state: 'occupied', pet: { type: 'quartz', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 5, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 6, isFavorite: true}},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'occupied', pet: { type: 'agate', level: 1, isFavorite: false}},
  { state: 'occupied', pet: { type: 'agate', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'agate', level: 4, isFavorite: true}},
]

const sortAll = () => {
  currentPets
    .sort((a) => (a.state === 'occupied' || a.state === 'equipped' ? -1 : 1))
        .sort((a, b) => {
            if (a.pet?.type < b.pet?.type) return -1;
            if (a.pet?.type > b.pet?.type) return 1;
            return 0;
        })
        .sort((a, b) => {
            if (a.pet?.type === b.pet?.type && a.pet?.level > b.pet?.level) return -1;
            if (a.pet?.type === b.pet?.type && a.pet?.level < b.pet?.level) return 1;
            return 0;
        })
        .sort((a, b) => {
            if (a.pet?.isFavorite || b.pet?.isFavorite) return -1;
            return 0;
        })
}

console.log('sorted', currentPets)

​

Answer 1

您需要考虑到undefined。我认为对数组进行多次排序是浪费资源，因为排序将需要大量的循环。

我只为你改变了isFavorite的类型。如果我是您，我将继续在第一个检查属性(isFavorite)下进行更多的代码。

​

const currentPets = [
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'occupied', pet: { type: 'quartz', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'quartz', level: 3, isFavorite: false}},
  { state: 'equipped', pet: { type: 'quartz', level: 6, isFavorite: true}},
  { state: 'occupied', pet: { type: 'quartz', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 5, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 6, isFavorite: true}},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'occupied', pet: { type: 'agate', level: 1, isFavorite: false}},
  { state: 'occupied', pet: { type: 'agate', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'agate', level: 4, isFavorite: true}},
]


const sortAll = () => {
  let tempA, tempB;

  return currentPets
    .sort((a, b) => {
        tempA = a.pet?.isFavorite
        tempB = b.pet?.isFavorite

        // you should refactor this if statement
        if (tempA !== tempB) {
          if (typeof tempA == 'undefined') { return 1  }
          if (typeof tempB == 'undefined') { return -1 }
          if (tempA < tempB)               { return 1  }
          if (tempA > tempB)               { return -1 }
        }

        // tempA = a.pet?.type
        // tempB = b.pet?.type
        //if (tempA !== tempB) {
          // ...
        //}

        return 0
    })
}

console.log('sorted', sortAll());

​

如果重构了代码，那么它应该是什么样的：

​

const currentPets = [
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'occupied', pet: { type: 'quartz', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'quartz', level: 3, isFavorite: false}},
  { state: 'equipped', pet: { type: 'quartz', level: 6, isFavorite: true}},
  { state: 'occupied', pet: { type: 'quartz', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 5, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 6, isFavorite: true}},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'occupied', pet: { type: 'agate', level: 1, isFavorite: false}},
  { state: 'occupied', pet: { type: 'agate', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'agate', level: 4, isFavorite: true}},
]


const sortAll = (arr) => {
  const UNSORTED = 0;
  let   result   = 0;

  return arr
    .sort((a, b) => {
        result = compareProperties(a.pet?.isFavorite, b.pet?.isFavorite)

        // if (result == UNSORTED) {
        //  result = compareProperties(a.pet?.type, b.pet?.type)
        // }
        
        // if (result == UNSORTED) {
        // ...

        return result
    })
}

const compareProperties = (tempA, tempB) => {
  if (tempA !== tempB) {
    if (typeof tempA == 'undefined') { return 1  }
    if (typeof tempB == 'undefined') { return -1 }
    if (tempA < tempB)               { return 1  }
    if (tempA > tempB)               { return -1 }
  }

  return 0
}

console.log('sorted', sortAll(currentPets));

​