ch08枚举--Enumerations

ch07闭包

8.0枚举语法-Enumeration Syntax

//使用关键字enum定义一个枚举，
enum SomeEnumeration {
    // enumeration definition goes here
}
//这儿有个指南针方向的枚举例子
enum CompassPoint {
    case North
    case South
    case East
    case West
}
//定义在枚举里的值(比如： North, South, East, 和 West)是枚举的case，你可以用关键字 case来添加新的枚举case
//说明：不像C和OC，swift的枚举case没有分配一个默认的整型值，在上面的例子中， North, South, East, 和 West没有默认等于0，1，2，3。
//在一行里定义多个case，用逗号,分开
enum Planet {
    case Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune
}
//每个枚举定义，都定义了一个新的类型。像swift中其他的类型一样，他们的名字(比如：CompassPoint 和 Planet)应该以大写字母开头，给枚举类型单数而不是复数名，
var directionToHead = CompassPoint.West
//directionToHead类型会被推断出，当用枚举CompassPoint中可能的值来初始化他的时候。一旦directionToHead被声明为CompassPoint，你可以用点语法设置他不同的CompassPoint值
directionToHead = .East
//directionToHead的类型已经知道了，所以当你给他赋值的时候，可以丢掉它的类型。

8.1用switch语句匹配枚举值－Matching Enumeration Values with a Switch Statement

directionToHead = .South
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")
case .West:
    print("Where the skies are blue")
}
// prints "Watch out for penguins"
//当考虑到枚举的case的时候，switch语句一定要考虑到每一个枚举的case值，如果switch的case语句忽略.West，那么代码不能被编译。
//如果switch语句没有考虑到枚举的所有情况，那么你可以提供一个default case来包含枚举其他所有的case
let somePlanet = Planet.Earth
switch somePlanet {
case .Earth:
    print("Mostly harmless")
default:
    print("Not a safe place for humans")
}// prints "Mostly harmless"

8.2关联值－Associated Values

//你可以定义一个swift枚举类型，来存储任何给定类型的关联值，如果需要，每一个枚举case对应的值的类型都是不同，
//比如：假设库存跟踪系统需要通过两种类型条形码来跟踪产品，一种条形码时一维条形码，使用0到9数字；另一种条形码时二维条形码，使用ISO 8859-1字符，可以编码成2953个字符的字符串
//swift中定义产品条形码可能如下：
enum Barcode {
    case UPCA(Int, Int, Int, Int)
    case QRCode(String)
}
//定义一个枚举类型叫做Barcode，枚举有两个case，一种是UPCA,其值关联了一个元组类型(Int, Int, Int, Int)；另一种是QRCode，关联了一个String类型的值
//这个定义没有定义任何实际的Int或者String类型的值，枚举仅仅定义了关联值的类型，当Barcode常量或者变量等于Barcode.UPCA 或者 Barcode.QRCode的时候，Barcode常量或者变量可以存储这些关联值
var productBarcode = Barcode.UPCA(8, 85909, 51226, 3)
//这个例子创建了一个新的变量productBarcode，分配给他一个 Barcode.UPCA值，并且关联了一个元组类型的值 (8, 85909, 51226, 3).
productBarcode = Barcode.QRCode("ABCDEFGHIJKLMNOP")
//关联值可以被提取出来作为switch语句的一部分，你提出每一个关联的值作为常量(关键字let开头)，或者变量(关键字var开头)
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).")
}// prints "QR code: ABCDEFGHIJKLMNOP."
//如果所有的关联值被提取出来作为常量或者变量，那么你可以在每一个case的前面放一个let，或者var
switch productBarcode {
case let .UPCA(numberSystem, manufacturer, product, check):
    print("UPC-A: \(numberSystem), \(manufacturer), \(product), \(check).")
case let .QRCode(productCode):
    print("QR code: \(productCode).")
}// prints "QR code: ABCDEFGHIJKLMNOP."

8.3原始值-Raw Values

//作为关联值的代替，枚举case预先填入默认值(原始值)，都是相同的类型
enum ASCIIControlCharacter: Character {
    case Tab = "\t"
    case LineFeed = "\n"
    case CarriageReturn = "\r"
}
//枚举ASCIIControlCharacter的原始值被定义为Character类型，
//原始值可以是strings,character,或者任意整型，浮点类型。每一个原始值的类型一定要和枚举什么的类型一致
//模糊分配原始值－Implicitly Assigned Raw Values
//当你用枚举存储整型活着字符串类型的原始值的时候，你没有必要为每一个case分配一个原始值，当你这样做的时候，swift会自动为你分配好值
//比如：当原始值时整型的时候，如果第一个case没有给值，那么他的原始值是0
enum Planets: Int {
    case Mercury = 1, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune
}
//在这个例子中，Planet.Mercury有一个精确的原始值1，Planet.Venus有一个模糊的元素值2，一次类推
//当原始值是字符串的时候，每一个case的模糊值是这个case的文本。
//在下面的例子中，字符串原始值为每一个方向的名字
enum CompassPoints: String {
    case North, South, East, West
}
//CompassPoint.South的模糊元素值是"South"
//你可以用他的rawValue属性为每一个case分配原始值
let earthsOrder = Planets.Earth.rawValue
// earthsOrder is 3
let sunsetDirection = CompassPoints.West.rawValue
// sunsetDirection is "West"
//从原始值初始化－Initializing from a Raw Value
//如果你用原始值类型定义了一个枚举，枚举会自动收到初始化，取原始值类型的值，并且返回一个枚举case活着nil。你可以用初始化尝试创建一个新的枚举实例
let possiblePlanet = Planets(rawValue: 7)
// possiblePlanet is of type Planets? and equals Planet.Uranus
//然而，不是所有的Int值都能匹配一个星球，因为这个，原始好初始化总是收到可选的枚举case。这个例子中，possiblePlanet是Planets?或者optional Planet
//如果你尝试找到9位置点星球，那么可选的星球会返回nil
let positionToFind = 9
if let somePlanet = Planets(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)")
}
// prints "There isn't a planet at position 9"

8.4递归枚举－Recursive Enumerations

//递归枚举是另一种枚举，有一个或者多个枚举case的关联值枚举，在枚举case前面插入关键字indirect来声明枚举是递归枚举
enum ArithmeticExpression {
    case Number(Int)
    indirect case Addition(ArithmeticExpression, ArithmeticExpression)
    indirect case Multiplication(ArithmeticExpression, ArithmeticExpression)
}
//你也可以在定义枚举的时候，写关键字indirect，
indirect enum ArithmeticExpressions {
   case Number(Int)
   case Addition(ArithmeticExpressions, ArithmeticExpressions)
   case Multiplication(ArithmeticExpressions, ArithmeticExpressions)
}
//这个枚举存储三种算术表达式：一个普通的数字，一个加法表达式，一个乘法表达式，Addition 和Multiplication case有关联值，
//和有递归结构的数据工作的递归函数是一种简单方式
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))
// prints "18"
//通过返回一个关联值，函数评估简单的数字，通过评估表达式在左边，和在右边，函数评估加法和乘法，然后加他们相加或者相乘