Swift4 基础部分: Enumerations

本文是学习《The Swift Programming Language》整理的相关随笔，基本的语法不作介绍，主要介绍Swift中的一些特性或者与OC差异点。

系列文章：

• Swift4 基础部分:The Basics
• Swift4 基础部分:Basic Operators
• Swift4 基础部分:Strings and Characters
• Swift4 基础部分:Collection Types
• Swift4 基础部分:Control Flow
• Swift4 基础部分:Functions
• Swift4 基础部分:Closures

Enumerations

You introduce enumerations with the enum keyword and place 
their entire definition within a pair of braces:

enum SomeEnumeration {
    // enumeration definition goes here
}

例子：

enum CompassPoint {
    case north
    case south
    case east
    case west
} 

Unlike C and Objective-C, Swift enumeration cases are not 
assigned a default integer value when they are created.

• Swift中枚举不会存在默认值

关联值(Associated Values)

You can define Swift enumerations to store associated 
values of any given type, and the value types can be 
different for each case of the enumeration if needed. 
Enumerations similar to these are known as discriminated 
unions, tagged unions, or variants in other programming 
languages.

• Swift中的枚举可以将每个枚举值关联上指定的一些值，这些值类型也可以不同

例子：

enum Shape{
    case Rectangle(x:Float,y:Float,width:Float,height:Float)
    case Circle((x:Float,y:Float),radius:Float)
}

func judgeShape(_ shape:Shape){
    switch shape {
    case Shape.Rectangle(let x,let y,let width,let height):
        print("Rectangle -> x:\(x),y:\(y),width:\(width),height:\(height)");
    case Shape.Circle((let x,let y), let radius):
        print("Circle -> x:\(x),y:\(y),radius:\(radius)");
    }
}

var rectangle = Shape.Rectangle(x: 10, y: 10, width: 100, height: 50);
var circle = Shape.Circle((x: 10, y: 10), radius: 100);
judgeShape(rectangle);
judgeShape(circle);

执行结果：

Rectangle -> x:10.0,y:10.0,width:100.0,height:50.0
Circle -> x:10.0,y:10.0,radius:100.0

原始数值(Raw Values)

Raw values can be strings, characters, or any of the 
integer or floating-point number types. Each raw value 
must be unique within its enumeration declaration.

• Swift中的枚举的值可以是字符串，字符，整型等多种数据类型

隐式赋值(Implicitly Assigned Raw Values)

For instance, when integers are used for raw values, the 
implicit value for each case is one more than the previous 
case. If the first case doesn’t have a value set, its 
value is 0.

When strings are used for raw values, the implicit value 
for each case is the text of that case’s name.

• Swift中枚举如果指定了数据类型，默认整型就是0开始,字符串就是枚举的名字

例子：

enum CompassPoint: String{
    case north, south, east, west
}
print(CompassPoint.north.rawValue);

enum Planet: Int{
    case mercury = 0, venus, earth, mars, jupiter, saturn, uranus, neptune
}
print(Planet.mercury.rawValue);

执行结果：

north
0

递归枚举(Recursive Enumerations)

A recursive enumeration is an enumeration that has another 
instance of the enumeration as the associated value for 
one or more of the enumeration cases. You indicate that an 
enumeration case is recursive by writing indirect before 
it, which tells the compiler to insert the necessary layer 
of indirection.

• Swift中存在递归枚举的写法，需要使用关键字indirect修饰它

例子：

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

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

print(evaluate(product))

执行结果：

18

个人觉得上述方式放入枚举中写很奇怪，觉得应该函数的方式去实现才更容易理解，这里只是说明了一种用法