JavaScript如何按照布尔属性对对象数组进行排序

a=[true,false,true,false,true];
 
a.sort(function(x, y) {
      a1=x?1:0
      b1=y?1:0
return a1-b1
    });

布尔数组需要有足够的条目来表示所有的转换，即从true到true，从true到false，从false到false，从false到true。

var boolarray = [true, false, true, true, false, false, true]
boolarray.sort( (a,b) => !(a ^ b) ? 0 : a ? -1 : 1)

这个排序方法是对输入的异或值进行反转。如果输入相同，则返回0；如果不同，则如果“a”为true，“b”必须为false，因此返回-1，反之返回1。

当'a'和'b'不同时，它们被排序，当它们相同时则被忽略。

要将此方法用于对象，请使用对象成员名称作为排序参数：

var objarray = [{xx:true}, {xx:false}, {xx:true}, {xx:true}, {xx:false}, {xx:false}, {xx:true}]
objarray.sort( (a,b) => !(a.xx ^ b.xx) ? 0 : a.xx ? -1 : 1)

我在 return (x.xx === y.xx) ? 0 : x ? -1 : 1; 上遇到了 TypeScript 错误。

当您想要按布尔属性排序时，这是我的解决方案。

this.mediaList.sort( (a: MediaAutosubscriptionModel, b: MediaAutosubscriptionModel) => {
    let status1: number = a.status === StatusEnum.ACTIVE ? 1 : 0;
    let status2: number = b.status === StatusEnum.ACTIVE ? 1 : 0;
    let comparison: number = 0;
    let direction: number = this.sortDirection === SortDirectionsEnum.ASC ? -1 : 1;
    if (status1 > status2) {
        comparison = direction;
    } else if (status1 < status2) {
        comparison = -1 * direction;
    }
        return comparison;
    });

不使用任何ES6函数，具有时间和空间优化 -

const data = [false, true, true, true, false, false, false, true];
let lastElementUnchecked;
for(let i=0; i<data.length; i++){
    if(data[i] && lastElementUnchecked !== undefined){
        let temp = data[i];
        data[i] = data[lastElementUnchecked];
        data[lastElementUnchecked] = temp;
        i = lastElementUnchecked;
        lastElementUnchecked = undefined;
    }else{
        if(!data[i] && lastElementUnchecked === undefined){
            lastElementUnchecked = i;
        }
    }
}
console.log(data)

const arr = [{ bool: true }, { bool: false }, { bool: false }, { bool: true }];

// Sorting the array to place true values first
const trueValFirst = arr.sort((a, b) => {
  // Converting boolean values to numbers and comparing them
  const boolA = Number(a.bool);
  const boolB = Number(b.bool);
  
  // Sorting in descending order
  return boolB - boolA;
});

console.log(trueValFirst);