Swift 如何按枚举值对对象进行排序？

我有

训练

课程，有

难度

属性

enum Difficulty: String {
  case easy = "easy"
  case moderate = "moderate"
  case hard = "hard"
}

class Workout {
  var name: String?
  var difficulty: Difficulty?
  .
  .
  .
}

我想按难度属性对一系列训练进行排序。我知道我可以通过将enum的原始值指定给Int值并按如下方式比较这些值来实现这一点：

data.sort { $0.workout.difficulty!.rawValue < $1.workout.difficulty!.rawValue }

data.sort{$0.workout.demobility！.rawValue<$1.workout.demobility！.rawValue}

但我真的希望这个枚举存储字符串，因为它可以方便地将它分配给一行中的标签文本，而不会出现难看的开关大小写错误，并且在某种程度上具有可比性

---

如何实现这一点？

在

枚举

上实施

可比

协议。它为您提供了一个

static func<（lhs:难度，rhs:难度）->Bool

方法，您可以在其中定义排序

下面是一个使用属性简化排序的完整示例

enum Difficulty: String, Comparable {
    case easy = "easy"
    case moderate = "moderate"
    case hard(String) = "hard"

    private var sortOrder: Int {
        switch self {
            case .easy:
                return 0
            case .moderate:
                return 1
            case .hard(_):
                return 2
        }
    }

     static func ==(lhs: Difficulty, rhs: Difficulty) -> Bool {
        return lhs.sortOrder == rhs.sortOrder
    }

    static func <(lhs: Difficulty, rhs: Difficulty) -> Bool {
       return lhs.sortOrder < rhs.sortOrder
    }
}

enum难度：字符串，可比较{
case easy=“easy”
case mediate=“中等”
大小写硬（字符串）=“硬”
私有变量排序器：Int{
切换自身{
案例。简单：
返回0
病例：中度：
返回1
案例.硬（uu）：
返回2
}
}
静态函数==（左：难度，右：难度）->Bool{
返回lhs.sortOrder==rhs.sortOrder
}
静态函数布尔{
返回lhs.sortOrder

使使用

data.sort { $0.workout.difficulty! < $1.workout.difficulty! }

data.sort{$0.workout.demobility！<$1.workout.demobility！}

编辑/更新：Swift 5.1或更高版本

您可以将枚举RawValue类型更改为整数，并使用其RawValue对训练进行排序。顺便说一句，您应该使用结构而不是类，并且与Igor建议的类似，您可以使您的结构具有可比性，而不是枚举：

struct Workout {
    let name: String
    let difficulty: Difficulty
}

---

---

---

---

可以使用枚举哈希值。顺便说一句，您应该使用结构而不是类。与Igor的建议类似，您可以使结构具有可比性，而不是使枚举具有可比性redundant@LeoDabus谢谢你的建议，你能提供完整的例子作为答案吗？我认为@IgorKulman的解决方案更合适。此解决方案将顺序绑定到

训练

，而不是

难度

。这只会为训练提供默认排序方法。您仍然可以根据需要使用谓词对其进行排序

sorted{$0.name<$1.name}

似乎您还可以将

Comparable

和

sortOrder

移动到

训练

。因此，对于不同的类，可以有不同的排序顺序。

extension Workout {
    enum Difficulty: Int { case easy, moderate, hard }
}

extension Workout: Comparable {
    static func <(lhs: Workout, rhs: Workout) -> Bool { lhs.difficulty.rawValue < rhs.difficulty.rawValue }
}

let wk1 = Workout(name: "night", difficulty: .hard)
let wk2 = Workout(name: "morning", difficulty: .easy)
let wk3 = Workout(name: "afternoon", difficulty: .moderate)

let workouts = [wk1, wk2, wk3]  // [{name "night", hard}, {name "morning", easy}, {name "afternoon", moderate}]

let sorted = workouts.sorted()  // [{name "morning", easy}, {name "afternoon", moderate}, {name "night", hard}]