列舉定義了一個通用型別的一組相關值，使我們可以在程式碼中以一種安全的方式來使用這些值。

基本語法：

使用 enum 關鍵字定義列舉

enum 列舉名{

case 成員值

}

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

成員值

一個列舉中定義的值，是列舉的成員值（成員），case 關鍵字表示一個新的成員值將被定義。

列舉的成員值不會被預設賦予一個整型值。

多個成員值可以出現在同一行上，用逗號隔開：

<span style="font-size:14px;">enum Planet {
    case Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune
}</span>
 

var value = CompassPoint.North

var directionToHead= CompassPoint.North
   directionToHead = .West

原始值

列舉成員可以被預設值（原始值）賦值，其中這些原始值具有相同的資料型別。

基本語法：

enum  列舉名：資料型別{

case 成員值 = 預設值

}

enum WeekDays:Int{
    case Monday         = 0
    case Tuesday         = 1
    case Wednesday      = 2
    case Thursday        = 3
    case Friday          = 4
}

可以使用 列舉成員值的 rawValue 屬性來訪問 成員的原始值

<span style="font-size:14px;">var day = WeekDays.Friday.rawValue
print(day)
//4</span>
 

在使用原始值為整數或者字串型別的列舉時，不需要顯式的為每一個成員賦值，這時，Swift將會自動賦值。

例如，當使用整數作為原始值時，隱式賦值的值依次遞增1。如果第一個值沒有被賦初值，將會被自動置為0。

enum WeekDays:Int{
    case Monday
    case Tuesday
    case Wednesday
    case Thursday
    case Friday
}


var day = WeekDays.Friday.rawValue
print(day)
//4  </span>

如果在定義列舉型別的時候使用了原始值，那麼將會自動獲得一個初始化方法，這個方法將原始值型別作為參

數，返回列舉成員或者nil 。你可以使用這種初始化方法來建立一個新的列舉變數。

enum WeekDays:String{
    case Monday = "Monday"
    case Tuesday
    case Wednesday
    case Thursday
    case Friday
}


var day = WeekDays(rawValue: "Friday")  //通過原始值 Friday  建立一個列舉變數
print(day)
//Optional(WeekDays.Friday) 

相關值

每個成員的資料型別可以不同。類似C中的聯合型別

enum Figure {
    case type (String)
    case area (Int,Int)
}


var type = Figure.type("長方形")
var area = Figure.area(100, 200)
print("type is \(type)  and  area  is \(area)")
//type is type("長方形")  and  area  is area(100, 200)

遞迴列舉

遞迴列舉是一種列舉型別，表示它的列舉中，有一個或多個列舉成員擁有該列舉的，其他成員作為相關值。

基本語法：

enum 列舉名{

indirect  case  成員值

}

或者

indirect enum 列舉名{

case 成員值 

}

在成員值 前加 indirect 關鍵字，表示該成員值，可以遞迴，在 列舉型別前加indirect 關鍵字，表示所有成員都可以遞迴。

enum ArithmeticExpression {
    case Number(Int)
    indirect case Addition(ArithmeticExpression, ArithmeticExpression)
    indirect 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)
    }
}
// 計算 (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))
// 輸出 "18"