Ios 如何在不改变主数组中原始顺序的情况下按布尔值进行swift排序？

我有一个模型数组，它有两个属性：

1。标题（字符串）

2。isSelected（布尔）

我想根据

isSelected

属性对它们进行排序，这样它就可以相对于源数组的序列进行排序。例如，如果全部为FALSE或TRUE，则排序后应该有相同的输出

但是如果我使用下面的方法，它会在基于BOOL属性对它们进行排序后改变原始排序

someArray = array.sort { $0.selected && !$1.selected }

我应该怎么做才能保留原始序列

编辑1

标题的排序顺序不在图片中。可能是服务器向我发送了4个标题为Z、Y、P、A的对象。因此，如果所有对象都为false，并且在我排序后，它应该像Z false、Y false、P false、A false一样。
您需要
someArray = array.sorted (by:{ $0.selected && !$1.selected && <#Add more conditions #>})

someArray=array.sorted（按：{$0.selected&&！$1.selected&}）

排序（按
排序）与
排序不同，不会改变原始数组


您应该使用
排序
方法，而不是
排序

let newArray = array.sorted { $0.selected && !$1.selected }

基本上，
sort
在同一数组中排序，
sorted
返回一个新数组，而不更改原始数组。如果您想保留从服务器获得的顺序，我建议您不要使用
sort
或
sorted
方法，因为它们不能保证保留带有s的键的原始顺序ame订单。我建议您编写自己的类似排序的函数：

struct Model {
    let title:String
    let selected:Bool
}

let array = [ Model(title: "Z", selected: true), Model(title: "Z", selected: false), Model(title: "Y", selected: false), Model(title: "P", selected: false), Model(title: "A", selected: true), Model(title: "A", selected: false)]

extension Array where Element == Model {
    func preserveSorted() -> [Model] {
        var selected:[Model] = []
        var notSelected:[Model] = []

        for model in self {
            if model.selected {
                selected.append(model)
            } else {
                notSelected.append(model)
            }
        }
        var output:[Model] = []
        output.append(contentsOf: selected)
        output.append(contentsOf: notSelected)
        return output
    }
}


var newArray:[Model] = array.preserveSorted()
print(newArray)
/* output:
[
    Model(title: "Z", selected: true),
    Model(title: "A", selected: true),
    Model(title: "Z", selected: false),
    Model(title: "Y", selected: false),
    Model(title: "P", selected: false),
    Model(title: "A", selected: false)
]
*/


如果您不想为您的模型创建可比较的扩展（例如，因为您在一些地方使用的是这些模型的不同顺序），可以使用排序方法，但提供不同的排序块：

struct Model {
    let title:String
    let selected:Bool
}

let array = [ Model(title: "a", selected: true), Model(title: "a", selected: false), Model(title: "b", selected: false), Model(title: "c", selected: true)]

let newArray = array.sorted { (lhs, rhs) -> Bool in
    if lhs.selected == rhs.selected {
        return lhs.title < rhs.title
    }
    return lhs.selected
}
print(newArray)

使用筛选操作可以更有效地进行排序，而不是排序：

let newArray = array.filter { $0.selected } + array.filter { !$0.selected }

不幸的是，
Array.sorted
不能保证稳定的排序，因此不能只按一个属性排序，而期望保留原始排序

不过，您可以轻松实现稳定排序（例如）

然后，您可以简单地使用：

let newArray = array.stableSorted {    
   let numeric1 = $0.selected ? 0 : 1
   let numeric2 = $1.selected ? 0 : 1

   return numeric1 <= numeric2
}

这是您的实际代码吗？您应该会看到一个编译器警告“Constant'someArray'推断为具有类型“（）”，这可能是意外的”我刚刚放置了一个原型，您（显然）正在寻找的是一个“稳定”排序
方法碰巧是稳定的，但这不能保证。另请参阅。谢谢，标题不在图片中。可能是服务器发送给我4个标题为Z、Y、P、A的对象。因此，如果所有对象都为false，并且在我排序后，它应该像Z false、Y false、P false、A false。@NSPratik我已经更新了我的答案，您能检查一下吗？谢谢，请参阅我的答案EDIT@RakeshaShastri贝因g | |或&&根据op的逻辑needs@Sh_Khan如果

，还有一个

if

。如果这也是根据OP的需要，您可以编写

array.sorted（by:）

。我看不出有什么区别。

let newArray = array.stableSorted {    
   let numeric1 = $0.selected ? 0 : 1
   let numeric2 = $1.selected ? 0 : 1

   return numeric1 <= numeric2
}

let newArray = array.stableSorted {
   return $0.selected == $1.selected || $0.selected
}