Tableau d'entrée comme objet de liste comme, [{ number: 13.23 , Active: false },{ number: 2.21 , Active: false },{ number: 2.3 , Active: true }];

La sortie prévue dans l'ordre décroissant trié comme, l'objet "actif" doit être en premier et tous les autres triés par ordre décroissant par numbers après l'enregistrement "actif". Essayé avec l'approche ci-dessous mais cela ne me donne pas une première entrée active. ce tri le décroissant par nombre mais actif ne venant pas en premier.

const arr = [{ number: 13.23 , Active: false },{ number: 2.21 , Active: false },{ number: 2.3 , Active: true }];

const customSortActiveShouldBeFirst = function(array) {
  let key = 'number';
  if (array && array.length > 0) {
    return array.sort(function(a, b) {
      var x = a[key];
      var y = b[key];
      return (x['Active'] === true ? 1 : (y - x));
    });
  }
  return array;
};
console.log(customSortActiveShouldBeFirst(arr))

Production attendue: L'objet actif doit être le premier dans le tableau de résultats, puis toutes les entrées décroissant par des nombres. comme, [{number: 2.3, Active: true }, {number: 13.23, Active: false}, {number: 2.21, Active: false}]

1
Cod29 2 juin 2020 à 19:40

5 réponses

Meilleure réponse

Triez d'abord par Active puis DSC du nombre lorsque les valeurs actives sont les mêmes.

const arr = [
  { number: 13.23, Active: false },
  { number: 2.21, Active: false },
  { number: 2.3, Active: true },
];

arr.sort((a, b) => {
  if (a.Active === b.Active) {
    return b.number - a.number;
  } else if (a.Active || !b.Active) {
    return -1;
  } else if (b.Active || !a.Active) {
    return 1;
  }
  return 0;
});

console.log(arr);
1
sivako 2 juin 2020 à 16:53

Vous pouvez filter par les éléments du tableau qui Active est true et false.

Puis triez les éléments du tableau qui Active est false

const arr = 
  [
    { number: 13.23 , Active: false },
    { number: 2.21 , Active: false },
    { number: 2.3 , Active: true }
  ];

const activeTrueArr = arr.filter(({ Active }) => Active);
const activeFalseArr = arr.filter(({ Active }) => !Active);

activeFalseArr.sort((a, b) => {
  return a.number < b.number ? 1 : -1;
})

console.log([...activeTrueArr, ...activeFalseArr])
1
zb22 2 juin 2020 à 16:54
const arr = [
    { number: 13.23, Active: false },
    { number: 2.21, Active: false },
    { number: 2.3, Active: true }
]
customSortActiveShouldBeFirst = function (array) {
    let key = 'number';
    if (array && array.length > 0) {
        return array.sort(function (a, b) {
            var x = a[key];
            var y = b[key];
            if (a.Active && b.Active) {
                return y - x;
            }
            if (a.Active) {
                return -1
            }
            if (b.Active) {
                return 1;
            }
            return y - x;
        });
    }
    return array;
};
console.log(customSortActiveShouldBeFirst(arr))

1
quan lili 3 juin 2020 à 00:04

Que se passe-t-il s'il y en a deux ou plus qui sont «actifs»?

Si tel est le cas, je les trierais également et les aurais tous avant les "inactifs" (également triés).

const arr = [{ number: 13.23 , Active: false },{ number: 2.21 , Active: false },{ number: 2.3 , Active: true }, { number: 4.3 , Active: true }];

const customSortActiveShouldBeFirst = function(array) {
  let key = 'number';
  if (array && array.length > 0) {
    return array.sort(function(a, b) {
      if (a['Active'] && b['Active']) return b[key] - a[key];
      if (a['Active']) return -1;
      if (b['Active']) return +1;
      return b[key] - a[key];
    });
  }
  return array;
};
console.log(customSortActiveShouldBeFirst(arr))

Sortie (avec un autre "actif" ajouté à l'entrée):

[
  {
    "number": 4.3,
    "Active": true
  },
  {
    "number": 2.3,
    "Active": true
  },
  {
    "number": 13.23,
    "Active": false
  },
  {
    "number": 2.21,
    "Active": false
  }
]


Exemple pour montrer que la réponse de @ rahul-dwivedi peut produire des résultats inattendus (pour répondre au commentaire que ma réponse fait trop):

const arr = [{ number: 13.23 , Active: false },{ number: 2.21 , Active: false },{ number: 2.3 , Active: true }, { number: 14.23 , Active: false }, { number: 1.3 , Active: true }];

arr.sort((a, b)=>{
  if(a.Active && !b.Active){
    return -1
  }
  return b.number - a.number //since you want in the descending number. For ascending order a.number - b.number
});

console.log(arr)

Sortie (de la réponse de @ rahul-dwivedi avec exemple d'entrée):

[
  {
    "number": 14.23,
    "Active": false
  },
  {
    "number": 2.3,
    "Active": true
  },
  {
    "number": 1.3,
    "Active": true
  },
  {
    "number": 13.23,
    "Active": false
  },
  {
    "number": 2.21,
    "Active": false
  }
]
1
Alex L 2 juin 2020 à 17:17

Vous pouvez faire quelque chose comme ça. Priortisez de sélectionner un élément s'il est actif. Ensuite, sélectionnez dont number est le plus grand.

const arr = [{ number: 13.23 , Active: false },{ number: 2.21 , Active: false },{ number: 2.3 , Active: true }];

  arr.sort((a, b)=>{
  if(a.Active && !b.Active){
     return -1
  }else if(!a.Active && b.Active){
     return 1
  } 
  return b.number - a.number //since you want in the descending number. For ascending order a.number - b.number
});

console.log(arr)
1
ABGR 2 juin 2020 à 17:23