Question

因此，我有一组特定用户的邀请（他从其他用户那里收到的邀请）。我希望前端根据其状态对这些邀请进行排序。 4个可能的类别，过期，已完成，已接受和未决。邀请是作为对象从数据库中提取的。这就是我对它们进行排序的方式。数组partArray包含所有邀请，需要将其分类为acceptedArr，expiredArr，completedArr和pendingArr。

for(let j = partarray.length-1;j>=0;j--){



           if(partarray[j].userStats[auth.uid]==1 &&partarray[j].inviteStat==1){

             acceptedArr.push(partarray[j].id)
             partarray.splice(j, 1);

           }
           else if(partarray[j].userStats[auth.uid]==-1||partarray[j].inviteStat==0){

               expiredArr.push(partarray[j].id)
               partarray.splice(j, 1);


           }
           else if(partarray[j].userStats[auth.uid]==0&&partarray[j].inviteStat==1){

               pendingArr.push(partarray[j].id)
               partarray.splice(j, 1);


           }else if(partarray[j].inviteStat==2){


               completedArr.push(partarray[j].id)
               partarray.splice(j, 1);


           }


         }



        }

如您所见，为了将邀请分类到acceptedArr中，它需要满足2个条件partarray[j].userStats[auth.uid]==1 && partarray[j].inviteStat==1，每个类别都有不同的条件。有没有一种方法可以更有效地实现我的工作？

Answer 1

为什么不只是这样过滤它们？

const acceptedArr = partarray.filter(invite => invite.userStats[auth.uid]===1 && invite.inviteStat===1).map(invite => invite.id);
const completedArr = partarray.filter(invite => invite.inviteStat === 2).map(invite => invite.id);

Answer 2

我会避免将数组分为4个类别，而应使用array.sort。

这是带有示例数据的实现。

const auth = {
  uid: 'test'
}

const partarray = [{
    userStats: {
      test: 1
    },
    inviteStat: 1
  },
  {
    userStats: {
      test: -1
    },
    inviteStat: 0
  },
  {
    userStats: {
      test: 0
    },
    inviteStat: 1
  },
  {
    userStats: {
      test: 1
    },
    inviteStat: 2
  }
]

const evaluateOrder = ({
  userStats,
  inviteStat
}) => {
  // lower value - higher ranking

  if (userStats[auth.uid] === 1 &&
    inviteStat === 1)
    return 1;

  if (userStats[auth.uid] === -1 &&
    inviteStat === 0)
    return 2;

  if (userStats[auth.uid] === 0 &&
    inviteStat === 1)
    return 3;

  if (inviteStat === 2)
    return 4;
}

const sortUsers = (array) => {
  array.sort((prev, next) => {

    const prevOrder = evaluateOrder(prev);
    const nextOrder = evaluateOrder(next);

    return prevOrder - nextOrder;
  })
  
  return array;
}

console.log(sortUsers(partarray))

Answer 3

不确定我是否了解您要执行的操作。不过，您可以使用switch语句并通过将公共代码移到底部来消除很多代码：

for (let j = partarray.length - 1; j >= 0; j--) {

  let el = partarray[j]
  let userStats = el.userStats[auth.uid]
  let inviteStat = el.inviteStat

  switch(inviteStat){

      case 0:
          //do something
          break;

      case 1:
        if(userStats == 0){
           //do something
        } else if(userStats == 1){
           //do something
        }
        break;

      case 2:
          //do something
          break;
  }

    if (userStats == -1 ){
      //do something    
    } 

    pendingArr.push(el.id)
    partarray.splice(j, 1);
}

有没有更有效的方法来对此数组进行排序？

3 个答案: