Swift_枚舉

Swift_枚舉

---

點擊查看源碼

空枚舉

//空枚舉
enum SomeEnumeration {
    // enumeration definition goes here
}

枚舉基本類型

//枚舉基本類型
enum CompassPoint {
    case north
    case south
    case east
    case west
}

簡寫

//簡寫
enum Planet {
    case mercury, venus, earth, mars, jupiter, saturn, uranus, neptune
}

枚舉語法

//枚舉語法
func testEnumerationSyntax() {
    
    //使用
    var directionToHead = CompassPoint.west
    //可不寫 前面的枚舉名
    directionToHead = .east
    print("\(directionToHead)")
    
    /*  print
     
     east
     
     */
}

枚舉匹配

//枚舉匹配
func testMatchingEnumeration() {
    
    var directionToHead = CompassPoint.south
    
    //if匹配
    if directionToHead == CompassPoint.south {
        directionToHead = .east
    }
    
    //switch匹配
    switch directionToHead {
    case .north:
        print("Lots of planets have a north")
    case .south:
        print("Watch out for penguins")
    case .east:
        print("Where the sun rises")
    default:
        print("default")
    }
    
    /*  print
     
     Where the sun rises
     
     */
}

關聯值

//關聯值
func testAssociatedValues() {
    //枚舉能夠和結構體類型的數據關聯使用
    enum Barcode {
        case upca(Int, Int, Int, Int)
        case qrCode(String)
    }
    
    // 初始化
    var productBarcode = Barcode.upca(8, 85909, 51226, 3)
    productBarcode = .qrCode("ABCDEFGHIJKLMNOP")
    
    //匹配
    switch productBarcode {//有警告 要求是常數
    case .upca(let numberSystem, let manufacturer, let product, let check):
        print("UPC-A: \(numberSystem), \(manufacturer), \(product), \(check).")
    case .qrCode(let productCode):
        print("QR code: \(productCode).")
    }
    
    //能夠不寫let
    switch productBarcode {
    case let .upca(numberSystem, manufacturer, product, check):
        print("UPC-A: \(numberSystem), \(manufacturer), \(product), \(check).")
    case let .qrCode(productCode):
        print("QR code: \(productCode).")
    }
    
    /*  print
     
     QR code: ABCDEFGHIJKLMNOP.
     QR code: ABCDEFGHIJKLMNOP.
     
     */
}

原始值

//原始值
func testRawValues() {
    enum ASCIIControlCharacter: Character {
        case tab = "\t"
        case lineFeed = "\n"
        case carriageReturn = "\r"
    }
    
    //隱式分配原始值
    enum Planet: Int {
        case mercury = 1, venus, earth, mars, jupiter, saturn, uranus, neptune
    }
    
    //原始值爲屬性名轉換
    enum CompassPoint: String {
        case North, South, East, West
    }
    
    print("\(Planet.earth.rawValue)")
    print("\(CompassPoint.West.rawValue)")
    
    // 經過原始值初始化
    let possiblePlanet = Planet(rawValue: 7)
    print("\(possiblePlanet)")
    let positionToFind = 9
    print("\(possiblePlanet)")
    
    // 當原始值不匹配時，返回爲nil
    if let somePlanet = Planet(rawValue: positionToFind) {
        switch somePlanet {
        case .earth:
            print("Mostly harmless")
        default:
            print("Not a safe place for humans")
        }
    } else {
        print("There isn't a planet at position \(positionToFind)")
    }
    
    /*  print
     
     3
     West
     Optional(Swift_枚舉.(testRawValues () -> ()).(Planet #1).uranus)
     Optional(Swift_枚舉.(testRawValues () -> ()).(Planet #1).uranus)
     There isn't a planet at position 9
     
     */
}

枚舉循環

//枚舉循環
func testRecursiveEnumerations() {
    //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) // 乘
    }
    
    // 函數使用
    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)
        }
    }
    
    // evaluate (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))
    
    /*  print
     
     18
     
     */
}