swift 枚举(枚举关联值、枚举原始值、递归枚举等)

这是我参与更文挑战的第9天，活动详情查看：更文挑战

枚举语法

使用enum关键字引入枚举，并将其整个定义放在{}中
多个case可以用多行或一行显示，其中一行显示用逗号(,)分隔
枚举名称以一个大写字母开头
```
enum Season {
    case spring
    case summer
    case autumn
    case winter
}

enum Season {
    case spring,summer,autumn,winter
}
```
注意:
Swift枚举在创建时不会分配默认整数值。spring，summer，autumn和winter不等于0，1，2，3。相反，这些值的类型是已经明确定义好的Season类型

枚举使用

当season的类型已知时，再次为其赋值可以省略枚举类型名

enum Season {
    case spring,summer,autumn,winter
}

var season = Season.spring
print(season)  //spring
season = .summer
print(season)  //summer

枚举是值类型

enum Season {
    case spring,summer,autumn,winter
}

let likeSeason = Season.summer
var currentSeason = likeSeason
currentSeason = .winter

print(likeSeason)     
print(currentSeason)  

log:
summer
winter

因为Season是一个枚举,所以currentSeason的值其实是likeSeason的一个拷贝副本，而不是currentSeason本身，因为它们是两个完全不同的实例。通过log证明currentSeason和likeSeason其中任何一个修改都不会影响另一个

枚举使用`switch`语句匹配枚举项

在判断一个枚举类型的值时，switch语句必须覆盖所有情况，忽略一个将无法通过编译

var season = Season.spring
switch season {
case .spring:
    print("spring")
case .summer:
    print("summer")
case .autumn:
    print("autumn")
case .winter:
    print("winter")
}

枚举迭代

在枚举名称后面使用CaseIterable，可以使枚举拥有一个关于所有枚举项的集合，调用枚举类型的allCases属性，可以获取这个枚举项的集合

enum Season:CaseIterable {
    case spring,summer,autumn,winter
}

let count = Season.allCases.count
print("枚举项共\(count)个") 
for season in Season.allCases {
    print(season)
}

log:
枚举项共4个
spring
summer
autumn
winter

枚举关联值

Swift中的枚举可以存储任意确定类型的关联值，这些值被称为枚举关联值

给一个枚举设置关联值，其中一个成员类型是(Int，Int，Int)，另一个是类型关联值的String,String)类型。创建一个名为Code的变量，并为其赋值
```
enum Code{
    case num(Int,Int,Int)
    case str(String,String)
}
var code = Code.num(2, 3, 3)
code =  .str("A", "B")
```

使用switch语句检查不同类型

匹配枚举项并且提取枚举项的关联值。可以使用let和var将每个关联值提取为常量或变量，以在case的正文中使用。

var code = Code.num(2, 3, 3)
    code =  .str("A", "B")


switch code {
case .num(let num1, let num2, let num3):
    print("\(num1),\(num2),\(num3)")
case .str(let str1, let str2):
    print("\(str1),\(str2)")
}

switch code {
case let .num(num1,num2,num3):
    print("\(num1),\(num2),\(num3)")
case let .str(str1,str2):
    print("\(str1),\(str2)")
}

原始值

枚举成员可以设置原始值，这些原始值的类型必须相同

enum Season:String {
    case spring = "A"
    case summer = "B"
    case autumn = "C"
    case winter = "D"
}

注意: 原始值和关联值是不同的。原始值是在定义枚举时被预先填充的值。对于一个特定的枚举成员，它的原始值始终不变。关联值是创建一个基于枚举成员的常量或变量时才设置的值，枚举成员的关联值可以变化。

原始值的隐式赋值

当使用整数作为枚举成员的原始值时，隐式赋值的值依次递增1

enum Season:Int {
    case spring = 1
    case summer
    case autumn
    case winter
}

当使用字符串作为枚举类型的原始值时，每个枚举成员的隐式原始值为该枚举成员的名称

enum Season:String {
    case spring 
    case summer
    case autumn
    case winter
}

使用枚举成员的rawValue属性可以访问该枚举成员的原始值

print(Season.spring.rawValue)

使用原始值初始化枚举实例可以通过 rawValue 初始化一个枚举成员，返回值则是枚举成员或nil 可以通过这个来判断这个新枚举成员是否在枚举值中

enum Season:Int {
    case spring
    case summer
    case autumn
    case winter
}
if let season = Season(rawValue: 5){
    switch season{
    case .spring:
        print("spring")
    case .summer:
        print("summer")
    case .autumn:
        print("autumn")
    case .winter:
        print("winter")
    }
}else{
    print("凉凉")
}

递归枚举

递归枚举是一种枚举类型
有一个或多个枚举成员使用该枚举类型的作为枚举成员
在枚举成员前加上 indirect 来表示该成员可递归

enum ArithmeticExpression {
    case number(Int)
    indirect case addition(ArithmeticExpression, ArithmeticExpression)
    indirect case multiplication(ArithmeticExpression, ArithmeticExpression)
}

应用

indirect enum ArithmeticExpression {
    case number(Int)
    case addition(ArithmeticExpression, ArithmeticExpression)
    case multiplication(ArithmeticExpression, ArithmeticExpression)
}
func evaluate(_ expression:ArithmeticExpression) -> Int {
    switch expression {
    case let .number(value):
        return value
    case let .addition(value1, value2):
        return evaluate(value1) + evaluate(value2)
    case let .multiplication(value1, value2):
        return evaluate(value1) - evaluate(value2)
    }
}


let num = ArithmeticExpression.number(5)
print(evaluate(num))    // 打印 "5"
print(evaluate(ArithmeticExpression.addition(num, num)))    // 打印 "10"
print(evaluate(ArithmeticExpression.multiplication(num, num)))    // 打印 "0"