J'ai donc un tableau d'invitations d'un certain utilisateur (invitations qu'il a reçues d'autres utilisateurs). Et je veux que le frontend trie ces invitations selon leur statut. 4 catégories possibles, expirées, complétées, acceptées et en attente. Les invitations sont récupérées en tant qu'objets de la base de données. Et voici comment je les trie. Le tableau partArray comprend toutes les invitations et doit être trié en acceptedArr, expiredArr, completedArr et 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);


           }


         }



        }

Comme vous pouvez le voir, pour que l'invitation soit triée dans l'Arr accepté, elle doit remplir 2 conditions partarray[j].userStats[auth.uid]==1 && partarray[j].inviteStat==1, il existe des conditions différentes pour chaque catégorie. Existe-t-il un moyen de réaliser ce que je fais de manière plus efficace?

2
nizhabib 25 avril 2020 à 00:49

3 réponses

Meilleure réponse

Pourquoi ne pas simplement les filtrer comme ça?

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);
2
Aleksey 24 avril 2020 à 22:13

Je ne sais pas si je comprends ce que vous essayez de faire. Vous pouvez cependant éliminer une grande partie de ce code avec une instruction switch et en déplaçant le code commun vers le bas:

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);
}
0
symlink 24 avril 2020 à 22:03

Je voudrais éviter de diviser le tableau en 4 catégories et utiliser à la place array.sort.

Voici l'implémentation avec des exemples de données.

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))
1
Józef Podlecki 24 avril 2020 à 22:25