枚举

二 枚举

枚举语法

enum CompassPoint {
    case north
    case south
    case east
    case west
}
也可以写在一行
enum Planet {
    case mercury, venus, earth, mars, jupiter, saturn, uranus, neptune
}

注意 上面的例子中，north、south、east和west不会隐式地等于0、1、2和3。

关联值

swift的枚举变量可以关联一个任何类型的值,并且类型可以不同
//就是每次创建枚举变量的时候可以关联一个值（就像类的成员变量，关联的值是属于枚举变量自己的）

enum Barcode {
    case upc(Int,Int,Int,Int)
    case qrCode(String)
}

var code     = Barcode.upc(1,2222,3333,5);
 code  = Barcode.qrCode("hahahaahh")
        
 switch code {
 case .upc(let n1, let n2, let n3, let n4):
         print("upc:\(n1),\(n2),\(n3),\(n4)");
 case .qrCode(let product):
         print("QR:\(product)");

第一个枚举关联了一个元祖，第二个关联了一个字符串。

原始值

枚举的原始值有点像类变量，不过不同的是原始值是不能改变的。原始值的意思就是说这个值是属于枚举项，并且不变。也有点儿类似c语言中的宏的作用

enum Planet: Int {
    case mercury = 1, venus, earth, mars, jupiter, saturn, uranus, neptune
}
//可以用rawValue来获取枚举项的原始值
let earthsOrder = Planet.earth.rawValue
//3

//可以用原始值来声明枚举变量
let possiblePlanet = Planet(rawValue: 7)


//类似宏的用法，定义了一些固定的常量
enum Constants: Double {
    case π = 3.14159
    case e = 2.71828
    case φ = 1.61803398874
    case λ = 1.30357
}
//圆的面积为
let s = Constants.π.rawValue * r*r / 2

递归枚举

上面说枚举可以关联一个任何类型的值那么自然也可以关联其他枚举类型，甚至可以关联自己类型的枚举实例，把关联自己类型的实例叫做 递归枚举，自己关联自己.
就是枚举变量的关联值还是枚举类型变量。
这种枚举要在前面加上 indirect

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

递归枚举用起来略绕。

        //(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));

    func evaluate(_ expression: ArithmeticExpression) -> Int {
        switch expression {
        case let .number(value):
            return value
        case let .addition(left, right):
            return evaluate(left) + evaluate(right)
        case let .multiplication(left, right):
            return evaluate(left) * evaluate(right)
        }
    }