swift学习记录（枚举）

枚举定义了一个通用类型的一组相关值，使我们可以在代码中以一种安全的方式来使用这些值。

基本语法：
使用
enum 关键字定义枚举
enum 枚举名{
case 成员值
}

enum CompassPoint {
case North
case South
case East
case West
}

成员值
一个枚举中定义的值，是枚举的成员值（成员），case 关键字表示一个新的成员值将被定义。

枚举的成员值不会被默认赋予一个整型值。
多个成员值可以出现在同一行上，用逗号隔开：

<span style="font-size:14px;">enum Planet {
case Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune
}</span>

使用枚举成员值赋值时，可以采用 “枚举名.成员值“的形式

var value = CompassPoint.North

当swift编译器能够根据上下文推断出类型时，也可以使用“ . 成员值”的形式来赋值

var directionToHead= CompassPoint.North
directionToHead = .West

如上，value 第一次 被赋值，第二次给value赋值时，编译器就能推断出是CompassPoint 类型，所以可以直接用 .West 给value赋值，增强代码的可读性。

原始值
枚举成员可以被默认值（原始值）赋值，其中这些原始值具有相同的数据类型。
基本语法：
enum 枚举名：数据类型{
case 成员值 = 默认值
}

enum WeekDays:Int{
case Monday         = 0
case Tuesday         = 1
case Wednesday      = 2
case Thursday        = 3
case Friday          = 4
}

访问 枚举成员原始值

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

<span style="font-size:14px;">var day = WeekDays.Friday.rawValue
print(day)
//4</span>

隐式赋值

在使用原始值为整数或者字符串类型的枚举时，不需要显式的为每一个成员赋值，这时，Swift将会自动赋值。
例如，当使用整数作为原始值时，隐式赋值的值依次递增1。如果第一个值没有被赋初值，将会被自动置为0。

enum WeekDays:Int{
case Monday
case Tuesday
case Wednesday
case Thursday
case Friday
}

var day = WeekDays.Friday.rawValue
print(day)
//4  </span>

使用原始值初始化枚举变量

如果在定义枚举类型的时候使用了原始值，那么将会自动获得一个初始化方法，这个方法将原始值类型作为参
数，返回枚举成员或者nil
。你可以使用这种初始化方法来创建一个新的枚举变量。

enum WeekDays:String{
case Monday = "Monday"
case Tuesday
case Wednesday
case Thursday
case Friday
}

var day = WeekDays(rawValue: "Friday")  //通过原始值 Friday  创建一个枚举变量
print(day)
//Optional(WeekDays.Friday)

因为 不是所有的传入值都能匹配到一个原始值，所以返回值为 可选类型。
相关值
每个成员的数据类型可以不同。类似C中的联合类型

enum Figure {
case type (String)
case area (Int,Int)
}

var type = Figure.type("长方形")
var area = Figure.area(100, 200)
print("type is \(type)  and  area  is \(area)")
//type is type("长方形")  and  area  is area(100, 200)

递归枚举
递归枚举是一种枚举类型，表示它的枚举中，有一个或多个枚举成员拥有该枚举的，其他成员作为相关值。
基本语法：
enum 枚举名{
indirect case 成员值
}
或者
indirect enum 枚举名{
case 成员值
}
在成员值 前加 indirect 关键字，表示该成员值，可以递归，在 枚举类型前加indirect 关键字，表示所有成员都可以递归。

enum ArithmeticExpression {
case Number(Int)
indirect case Addition(ArithmeticExpression, ArithmeticExpression)
indirect case Multiplication(ArithmeticExpression, ArithmeticExpression)
}

func evaluate(expression: ArithmeticExpression) -> Int {
switch expression {
case .Number(let value):
return value
case .Addition(let left, let right):
return evaluate(left) + evaluate(right)
case .Multiplication(let left, let right):
return evaluate(left) * evaluate(right)
}
}
// 计算 (5 + 4) * 2
let five = ArithmeticExpression.Number(5)
let four = ArithmeticExpression.Number(4)
let sum = ArithmeticExpression.Addition(five, four)

let product = ArithmeticExpression.Multiplication(sum, ArithmeticExpression.Number(2))
print(evaluate(product))
// 输出 "18"