如何对第一个记录应该特定的javascript数组进行排序，然后按降序排列

Question

输入数组作为列表对象，如[{ number: 13.23 , Active: false },{ number: 2.21 , Active: false },{ number: 2.3 , Active: true }];

预期的降序排序输出为，“活动”对象应该是第一个，所有其他降序排序在“活动”记录之后按numbers。 尝试使用以下方法，但它并没有让我成为第一个条目。这按数字降序排序，但活动不是第一个。

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))

预期输出： 活动对象在结果数组中排在第一位，然后是所有条目按数字降序排列。比如，[{ number: 2.3 , Active: true },{ number: 13.23 , Active: false },{ number: 2.21 , Active: false }]

Answer 1

当 Active 值相同时，首先按Active 排序，然后是数字的 DSC。

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);

Answer 2

您可以通过Active 是true 和false 的数组项来filter。

然后对数组中Active为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])

Answer 3

如果有两个或更多“活跃”的会发生什么？

如果是这样，我也会对这些进行排序，并将它们全部放在“非活动”之前（也排序）。

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))

输出（在输入中添加了一个“活动”）：

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

---

---

显示@rahul-dwivedi 的回答可能会产生意外结果的示例（以解决我的回答做得太多的评论）：

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)

输出（@rahul-dwivedi 的回答与示例输入）：

[
  {
    "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
  }
]

Answer 4

你可以做这样的事情。如果元素处于活动状态，则优先选择它。然后，选择number更大的那个。

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)

Answer 5

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))