Swift5.1学习随笔之枚举enum

Swift的枚举非常强大好用

如果变量有固定几种取值，建议用枚举

基本用法

enum Direction {
    case north
    case south
    case east
    case west
}
//等价写法
enum Direction {
    case north, south, east, west
}

//使用
var dir = Direction.west
dir = Direction.east
dir = .north // 等价 dir = Direction.north
print(dir) // north

//用在switch上
switch dir {
case .north: //等价写法 case Direction.north:
    print("north")
case .south:
    print("south")
case .east:
    print("east")
case .west:
    print("west")
}

关联值 Associated Values

有时候会将枚举的成员值跟其他类型的关联存储在一起，方便使用
小技巧：如果你懒得敲那么多case，可以只写一个switch xxx { }， 然后等Xcode报错点击自动fix修复补上所有的case

//Score分数有时候使用具体数字表示，比如100 90 60。有时候使用A B C等级表示
enum Score {
    case points(Int) //等价 == case points(num:Int)，可以省略标签名
    case grade(Character)
}

var s = Score.points(98)
var s1 = Score.grade("A")

switch s {
case let .points(value):
    print("points == ",value)
case let .grade(value):
    print("grade == ",value)
}

enum Date {
    case digit(year: Int, month: Int, day: Int) //年月日的元组，比如 2020 4 13
    case string(String) //字符串，比如 “20200413”
}
var date1 = Date.digit(year: 2020, month: 4, day: 13)
var date2 = Date.string("20200413")

switch date1 {
case .digit(year: let year, month: let month, day: let day):
    print(year, month, day)
case let .string(value):
    print(value)
}

原始值 Raw Value

枚举成员可以使用相同类型的默认值预先关联，这个默认值称为：原始值

: Character为原始值类型，该🌰中表示枚举PokerSuit的原始值类型为Character

enum PokerSuit: Character {
    case spade = "♠️" //"♠️"原始值
    case heart = "♥️" //"♥️"原始值
    case diamond = "♦️" //"♦️"原始值
    case club = "♣️" //"♣️"原始值
}

var suit = PokerSuit.spade
print(suit) // spade
print(suit.rawValue) //♠️
print(PokerSuit.club.rawValue) //♣️

enum Grade: String {
    case perfect = "A"
    case great = "B"
    case good = "C"
    case bad = "D"
}
print(Grade.perfect.rawValue) // A
print(Grade.great.rawValue) // B
print(Grade.good.rawValue) // C
print(Grade.bad.rawValue) // D

隐式原始值 Implicitly Assigned Raw Values

如果枚举的原始值类型是Int、String，Swift会自动分配原始值（即原始值 == 成员命名）

enum Direction: String {
    case north = "north"
    case south = "south"
    case east = "east"
    case west = "west"
}
//等价于
enum Direction: String {
    case north, south, east, west
}

print(Direction.north) // north
print(Direction.north.rawValue) // north

enum Season: Int {
    case sprint, summer, autum, winter
}
print(Season.sprint.rawValue) // 0
print(Season.summer.rawValue) // 1
print(Season.autum.rawValue) // 2
print(Season.winter.rawValue) // 3

// 如果自己赋值了原始值，那之后的成员值在之上递增
enum Season: Int {
    case sprint = 1, summer, autum = 4, winter
}
print(Season.sprint.rawValue) // 1
print(Season.summer.rawValue) // 2
print(Season.autum.rawValue) // 4
print(Season.winter.rawValue) // 5

递归枚举 Recursive Enumeration

如果枚举内部的成员的关联值用到了自身的枚举，那就成为递归枚举前面加上关键字indirect，否则编译器会报错，看下面两种写法

indirect enum ArithExpr {
    case number(Int)
    case sum(ArithExpr, ArithExpr)
    case difference(ArithExpr, ArithExpr)
}

enum ArithExpr {
    case number(Int)
    indirect case sum(ArithExpr, ArithExpr)
    indirect case difference(ArithExpr, ArithExpr)
}

举个使用🌰

//使用switch实现一个计算函数
func calculate(_ expr: ArithExpr) -> Int {
    switch expr {
    case let .number(value):
        return value
    case let .sum(left, right):
        return calculate(left) + calculate(right)
    case let .difference(left, right):
        return calculate(left) - calculate(right)
    }
}
calculate(difference) // 7