枚举为一组相关的值定义了一个共同的类型，使你可以在你的代码中以类型安全的方式来使用这些值。

如果你熟悉 C 语言，你会知道在 C 语言中，枚举会为一组整型值分配相关联的名称。Swift 中的枚举更加灵活，不必给每一个枚举成员提供一个值。如果给枚举成员提供一个值（称为“原始”值），则该值的类型可以是字符串，字符，或是一个整型值或浮点数。

枚举语法

enum SomeEnumeration {
    // 枚举定义放在这里
}

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

enum Planet {
    case Mercury, Venus, Earth, Mars
}

var directionToHead = CompassPoint.West
directionToHead = .West

使用switch语句匹配枚举值

let somePlanet = Planet.Earth
switch somePlanet {
case .Earth:
    print("Mostly harmless")
default:
    print("Not a safe place for humas")
}

关联值

enum Barcode {
case UPCA(Int, Int, Int, Int)
case QRCode(String)
}
var productBarcode = Barcode.UPCA(8, 85909, 51226, 3)
productBarcode = .QRCode("ABCDEFG")

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)")
} //输出 "QR code: ABCD"

原始值

enum ASCIIControlCharacter: Character {
    case Tab = "\t"
    case LineFeed = "\n"
    case CarriageReturn = "\r"
}

//原始值的隐式赋值
enum Planet1: Int {
    case Mercury = 1, Venus, Earth, Mars
}

enum CompassPoint1: String {
    case North, South, East, West
}

let earthsOrder = Planet1.Earth.rawValue // 3
let sunsetDirection = CompassPoint1.West.rawValue //West

//使用原始值初始化枚举实例
let possiblePlant = Planet1(rawValue: 1)!

let positionToFind = 9
if let somePlanet = Planet1(rawValue: positionToFind) {
    switch somePlanet {
    case .Earth:
        print("earth")
    default:
        print("default")
    }
} else {
    print("There isn't a planet at position \(positionToFind)")
}

递归枚举

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

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

let five = ArithmeticExpression.Number(5)
let four = ArithmeticExpression.Number(4)
let sum = ArithmeticExpression.Addition(five, four)
let product = ArithmeticExpression.Multiplication(sum, ArithmeticExpression.Number(2))

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)
    }
}

print(evaluate(product)) // 输出 "18"

原文链接

--EOF--