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

枚举语法

• 枚举名字以一个大写字母开头

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

注意：Swift枚举在创建时未分配默认整数值。spring，summer，autumn和winter不等于隐式0，1，2和3。相反，这些值的类型是已经明确定义好的Season类型

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

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

---

枚举是值类型

enum Color{
    case red
    case green
    case yellow
}
let currentColor = Color.yellow

//因为Color是一个枚举,所以rememberedColor的值其实是currentColor的一个拷贝副本，而不是currentColor本身,它们是两个完全不同的实例
var rememberedColor = currentColor
rememberedColor = .green

//通过log证明currentColor和rememberedColor其中任何一个修改都不会影响另一个
print(currentColor)     //yellow
print(rememberedColor)      //green

---

使用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 协议

枚举遵循CaseIterable 协议

enum Season:CaseIterable {
    case spring
    case summer
    case autumn
    case winter
}
let count = Season.allCases.count
print(count)  //4
for season in Season.allCases {
    print(season)
}
//spring
//summer
//autumn
//winter

---

关联值

Swift 枚举可以用来存储任意类型的关联值

声明存储不同类型关联值的枚举成员(这个定义不提供任何Int或String类型的关联值)
一个成员值是(Int，Int，Int)类型关联值的num
一个成员值是(String,String)类型关联值的str

enum Code{
    case num(Int,Int,Int)
    case str(String,String)
}

创建了一个名为code的变量，并为Code.num和Code.str赋值

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

使用switch语句检查不同类型

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

//如果枚举的所有关联值都被提取为常量或者变量，则可以在前面放置单个var或let注释，以简洁起见
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来让整个枚举成员在需要时可以递归

indirect enum ArithmeticExpression {
    case number(Int)
    case addition(ArithmeticExpression, ArithmeticExpression)
    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"