一个枚举定义了一组具有相同类型、有限个数离散值的一个类型。我们可以用枚举来表示一盏交通灯当前可能所处的状态，比如处于红灯、黄灯或绿灯状态；也可以用枚举来表示我们画画所要使用的颜料颜色，比如红、橙、黄、绿、青、蓝、紫、白、黑等等。
在许多面向过程或面向对象的编程语言中都会有枚举类型。像C以及Objective-C中的枚举类型默认为与整数类型 int 兼容。而在Swift中，我们可以自己指定一个枚举与哪种类型兼容，可以是整数类型，浮点数类型、字符串类型等等，使得枚举类型更为灵活丰富。
我们这里要注意的是，Swift编程语言中，枚举类型属于值类型，而不是引用类型。

枚举类型与枚举对象的一般定义

Swift编程语言中按照如下语法形式来定义枚举类型：

enum Enumeration {
case value1
case value2
case value3; case value4, value5
case value6
}

这里 Enumeration 为一个枚举类型；value1 到 value6 都是 Enumeration 枚举类型所定义的枚举值（Swift编程语言官方称为：enumeration cases）。我们可以看到，定义一个枚举类型由关键字 enum 引出。而定义该枚举类型中的枚举值则由关键字 case 引出。其中每个声明的 case 语句可用换行符或分号进行分隔；同时，一条 case 语句中可以包含多个枚举值，每个枚举值之间用逗号分隔。
枚举中的每个枚举值其实就是该枚举类型的一个已被定义好的对象。枚举值的生命周期则根据它所属的枚举类型所在的作用域来定。如果一个枚举类型定义在文件作用域，那么它的枚举值则具有整个执行程序的生命周期；如果一个枚举类型定义在函数体内，那么它的枚举值则具有该函数范围的生命周期，并且该枚举类型在此函数外部不可见。
我们要用一个枚举类型来声明一个枚举对象，并为它初始化也很简单，可以直接用该枚举类型的枚举值为它初始化即可。我们看以下代码：

/// 这里定义了一个表示交通灯的枚举类型
enum TrafficLight {
case red, yellow, green
}
 
// 这里定义了一个TrafficLight枚举类型常量light，
// 然后先用绿灯值对它初始化
let light = TrafficLight.green
 
// 这里定义了一个TrafficLight枚举类型变量light2，
// 并用红灯值对它进行初始化
var light2 = TrafficLight.red
 
// 这里将light2的值修改为黄灯值
light2 = TrafficLight.yellow
 
// 这里输出：light = green, light2 = yellow
print("light = \(light), light2 = \(light2)")

我们上面可以看到，要使用某个枚举类型中的某个枚举值，可以用该枚举类型通过成员访问操作符 . 来访问指定的枚举值。如果我们之前学过Java，那么会看到Swift编程语言的枚举与Java中的枚举十分类似，枚举值也就好比于枚举类型的类型属性。

如果我们所要访问的枚举值所属的枚举类型可以通过当前上下文被Swift编译器推导出来，那么我们还能使用缩略的点语法来表示。我们可以看以下代码。

/// 这里定义了一个表示交通灯的枚举类型
enum TrafficLight {
case red, yellow, green
}
 
// 由于我们这里已经声明了
// light具有TrafficLight枚举类型，
// 所以我们这里可以使用缩略点语法来指定green枚举值。
// 这里的.green相当于被缩略的TrafficLight.green的表示
let light: TrafficLight = .green
 
/// 我们这里定义了一个函数foo，
/// 它带有一个形参，类型为TrafficLight枚举类型
func foo(light: TrafficLight) {
print("light = \(light)")
}
 
// 由于函数foo的形参已经表明为TrafficLight类型，
// 我们这里可以使用缩略点语法来指定red枚举值
foo(light: .red)
 
// 以下case语句都使用了缩略点语法
switch light {
case .red:
print("This is a red light")
 
case .yellow:
print("This is a yellow light")
 
case .green:
print("This is a green light")
}
 
// 这里定义了一个元组常量tuple，
// 它带有两个元素，
// 每个元素类型均为TrafficLight。
// 这里使用缩略点语法构造了一个元组字面量
let tuple: (TrafficLight, TrafficLight) = (.red, .yellow)

上述代码中，我们可以看到使用缩略点语法的一些场合。我们在自己定义枚举类型的时候需要注意枚举值的命名，以及在定义函数时也要注意参数命名，否则我们直接使用缩略点语法可能会给代码阅读者带来一些困扰。如果我们有一个良好的命名的话，其实用缩略点语法还是十分简洁方便的。

指定基本类型与原生值

Swift编程语言中的枚举类型可以对它指定一个基本类型，使得该枚举中的枚举值都具有所指定的基本类型。这样，我们还能为枚举值指定该基本类型的原生值。在Swift中，能够用于指定枚举的基本类型有：各类整数类型，各类浮点数类型，字符类型以及字符串类型。这些类型都遵循了 RawRepresentable 协议以及 Equatable 协议，并且拥有自己的字面量表示法。我们看以下代码示例。

enum IntEnum: Int {
case zero
case one = 1, two, three
case six = 6, seven, eight
}
 
print("one = \(IntEnum.one.rawValue)")
print("two = \(IntEnum.two.rawValue)")
print("three = \(IntEnum.three.rawValue)")
print("six = \(IntEnum.six.rawValue)")
print("seven = \(IntEnum.seven.rawValue)")
print("eight = \(IntEnum.eight.rawValue)")
 
/// 将DoubleEnum指定为Double类型
enum DoubleEnum: Double {
case one = 1.0, two = 2.0
case π = 3.14159
case e = 2.71828
}
 
print("one = \(DoubleEnum.one.rawValue)")
print("two = \(DoubleEnum.two.rawValue)")
print("π = \(DoubleEnum.π.rawValue)")
print("e = \(DoubleEnum.e.rawValue)")
 
/// 将CharacterEnum指定为CharacterEnum类型
enum CharacterEnum: Character {
case apple = ""
case orange = "🍊"
case banana = "🍌"
case cherry = "🍒"
}
 
print("apple = \(CharacterEnum.apple.rawValue)")
print("orange = \(CharacterEnum.orange.rawValue)")
print("banana = \(CharacterEnum.banana.rawValue)")
print("cherry = \(CharacterEnum.cherry.rawValue)")
/// 将StringEnum指定为String类型
enum StringEnum: String {
case potato = "土豆"
case tomato = "番茄"
case 马铃薯
case 西红柿
}
 
print("potato = \(StringEnum.potato.rawValue)")
print("tomato = \(StringEnum.tomato.rawValue)")
print("马铃薯 = \(StringEnum.马铃薯.rawValue)")
print("西红柿 = \(StringEnum.西红柿.rawValue)")

上述代码分别列出了指定了整数类型、浮点数类型、字符类型以及字符串类型的枚举，并指定并访问每个枚举值所对应的原生类型的值，即原生值（raw value）。每个指定了基本类型的枚举的对象实例都会有自己的实例属性 rawValue 用于获取当前枚举值所指定的原生类型的值。我们可以看到，为每个具有原生类型的枚举的枚举值指定原生值的时候，使用的是与该原生类型相兼容的字面量。Swift与C语言不同，C语言在指定每个枚举符的值的时候可以使用任意形式的常量表达式，但Swift则不行。我们看以下例子：

enum MyEnum: Int {
case one = 1
 
// 这里编译报错：
// 指定枚举case的原生值必须用一个字面量
case two = one + 1
}

另外与C语言类似的是，如果我们用整数类型来指定一个枚举，那么其枚举值的原生值的指定可以缺省。如果当前枚举值的原生值缺省，那么根据以下规则来判定当前值：如果当前枚举值作为枚举的第一个成员，那么它的值默认为0；否则，当前枚举值为上一个枚举值加1之后的值。我们可以根据上述代码中 IntEnum 枚举类型中的枚举值来掌握这个语法规则。
此外，如果我们用字符串类型来指定一个枚举，那么也可以为枚举值缺省指定原生值。如果对于指定了字符串类型的枚举中的某个枚举值不指定原生值，那么该枚举值的原生值就是该枚举值的标识符所构成的字符串字面量。我们可以参考上述代码中 StringEnum 枚举类型中的枚举值的情况。
我们还要注意的是，枚举中的枚举值都是属于常量，因此我们不能试图去修改这些枚举值所指定的原生值。
对于指定了原生类型的枚举类型，我们可以使用Swift所提供的指定原生值的初始化器init(rawValue:) 来实例化一个枚举对象。它返回的是一个Optional枚举类型，也就是说如果我们所传入的原生值不存在于该枚举类型中的任一枚举值，那么就会返回空。我们下面来看些例子。

/// 这里定义了枚举类型TrafficLight，
/// 并将它原生类型指定为UInt
enum TrafficLight: UInt {
case red // 默认为0
case yellow // 值为1
case green // 值为2
}
 
// 我们这里使用TrafficLight的init(rawValue:)初始化器来构造一个TrafficLight的对象实例
// 这里的light是一个TrafficLight的Optional类型，
// 即 TrafficLight?
var light = TrafficLight(rawValue: 0)
if let l = light {
print("light is: \(l)")
print("light value is: \(l.rawValue)")
}
 
// 这里用5原生值来构造一个TrafficLight对象，
// 由于TrafficLight枚举中没有值为5的枚举值，
// 所以这里的light得到的是一个空值
light = TrafficLight(rawValue: 5)
if light == nil {
print("light is null!")
}
 
/// 这里定义了一个枚举类型MyNumber，
/// 其原生类型为Float
enum MyNumber: Float {
case 一 = 1.0
case 一点五 = 1.5
case 三点二五 = 3.25
}
 
// 这里用原生值1.5来构造一个MyNumber枚举对象
var num = MyNumber(rawValue: 1.5)
 
if let n = num {
print("num is: \(n)")
print("num value is: \(n.rawValue)")
}
 
// 我们这里也可以直接显式使用init构造器。
// 这里使用原生值3.2构造一个MyNumber对象。
// 由于3.2不属于MyNumber枚举中任一枚举值，
// 所以这里得到的num为空值
num = MyNumber.init(rawValue: 3.2)
 
if num == nil {
print("num is null!")
}

枚举关联值

枚举关联值与原生值类似的是，它也是将某个值与指定的枚举case存放在一起。不过枚举关联值的语法对每个枚举case均可指定不同类型、不同个数的关联值。因此就所指定的值的类型与个数而言，枚举关联值比原生值要灵活得多。这里各位要注意的是，如果我们为一个枚举类型中的任一个枚举case用上了枚举关联值，那么对于该枚举类型就不能为它指定一个原生类型，也不能为其枚举case指定原生值。枚举关联值的语法很简单，我们直接看以下代码.

/// 这里定义了一个枚举MyTestEnum，
/// 它枚举case中含有关联值
enum MyTestEnum {
/// 这里的value1具有一个Void类型的关联值
case value1(Void)
/// 这里的value2具有一个Int类型的关联值
case value2(Int)
 
/// 这里的value3具有Float、Int、Void与String
/// 这四个类型的关联值
case value3(Float, Int, Void, String)
 
/// 这里的value4具有三个关联值，
/// 第一个是一个[String:Int]的字典类型，
/// 第二个是一个[Double]的数组类型，
/// 第三个是一个(Int, Double)元组类型
case value4(dict: [String:Int], array:[Double], tuple: (Int, Double))
 
/// value5不具有任何关联值
case value5
}

我们看到，枚举关联值的语法很像元组，这就好比将一个元组与一个枚举case相关联一样。上述 MyTestEnum 类型中，除了 value5 没有指定关联值之外，其余的四个枚举case都指定了关联值。一旦我们为某一枚举case指定了关联值，那么我们在引用它的时候就必须为它加上关联值相应的“实参”，此时它看上去就如同做一个函数调用一般。我们看以下代码：

// 这里用value1来初始化e1，
// 我们也可使用：let e1 = MyTestEnum.value1( () )
let e1 = MyTestEnum.value1()
 
// 输出：e1 = value1
print("e1 = \(e1)")
 
// 这里用value2来初始化e2，
// 这里用的关联值为10
let e2 = MyTestEnum.value2(10)
 
// 输出：e2 = value2(10)
print("e2 = \(e2)")
 
// 这里用value3对e3做初始化，
// 并且对应指定了4个关联值
let e3 = MyTestEnum.value3(0.5, 2, (), "hello")
 
// 输出：e3 = value3(0.5, 2, (), "hello")
print("e3 = \(e3)")
 
// 这里用value4对e4做初始化，
// 并且对dict、array与tuple传了相应的关联值。
// 这里同使用元组字面量类似，
// 有标签的必须加上标签
let e4 = MyTestEnum.value4(dict: ["one":1, "two":2],
array: [1.0, 2.0, 3.0],
tuple: (1, 2.0))
 
// 这里用value5对e5做初始化，
// 由于value5没有关联值，
// 所以后面不能跟()
let e5 = MyTestEnum.value5
 
// 编译报错：
// 不能调用非函数类型MyTestEnum的值
_ = MyTestEnum.value5()

我们看到上述代码使用枚举case的关联值也很简单，根据枚举case所定义的关联值的类型以及标签来指定相应类型的常量或变量即可。所以这正如之前所说的，枚举关联值就仿佛将一个元组字面量与一个枚举值关联在了一起。所以在Swift官方书册中也提到，具有关联值的枚举类型类似于其他编程语言中的分歧联合体（ discriminated unions）、带有标签的联合体（tagged unions）或变异体（variants）。这怎么理解呢？比如对于上述代码中的枚举类型 MyTestEnum，它具有5个枚举case，也就是说具有5种不同的情况。对于每种情况，我们可以用当前枚举case的关联值类型所指定的方式来获取其关联值。因此，我们最常用的获取带有关联值的枚举类型对象的当前枚举case关联值的方式就是使用 switch-case 语句，对于各个不同的情况做不同处理。

/// 这里定义了一个用于处理MyTestEnum枚举对象的函数
/// - parameter en: MyTestEnum枚举对象
func processMyTestEnum(_ en: MyTestEnum) {
 
// 这里通过switch-case语句用来捕获枚举关联值的方式
// 酷似对元组对象的元素萃取
switch en {
case .value1(let value):
print("value1 is: \(value)")
 
case .value2(var value):
value += 10
print("value2 is: \(value)")
case .value3(let tuple):
// 这里直接用一个元组进行捕获value3的关联值
print("Float value: \(tuple.0)")
print("Int value: \(tuple.1)")
print("String value: \(tuple.2)")
 
case .value4(let dict, var array, let tuple):
// 这里通过定义三个对象来分别捕获value4的关联值
print("dict is: \(dict)")
array += [4.0, 5.0, 6.0]
print("array = \(array)")
print("tuple is: \(tuple)")
 
case .value5:
// 由于value5不具备关联值，
// 因此这里不能使用元素捕获的形式
print("This is value5")
}
}
 
processMyTestEnum(e1)
processMyTestEnum(e2)
processMyTestEnum(e3)
processMyTestEnum(e4)
processMyTestEnum(e5)

从Swift 3.0开始起，Swift也引入了通过 if 语句以及 guard 语句来捕获枚举关联值的语法形式。在这种语法体系下，是将 if 或 guard 与 case 关键字连用指定一个枚举case，然后对该枚举case的关联值进行捕获。我们下面来看些例子。

if case let .value1(value) = e1 {
// 这里的value仅对当前if语句可见。
// 输出：value1 = ()
print("value1 = \(value)")
}
 
if case var .value2(value) = e2 {
value += 10
// 输出：value2 = value2(10)
print("value2 = \(e2)")
}
 
if case let .value3(tuple) = e3 {
// 这里也是直接通过一个元组进行捕获
print("Float value: \(tuple.0)")
print("Int value: \(tuple.1)")
print("String value: \(tuple.2)")
}
 
// 这里通过分别指定三个对象对e4的关联值进行捕获，
// 同时，这三个对象对当前作用域可见
guard case .value4(let dict, var array, let tuple) = e4 else {
exit(0)
}
 
print("dict = \(dict)")
 
array += [-1.0, -2.0, -3.0]
 
print("array = \(array)")
 
print("tuple = \(tuple)")
 
if case .value1(let value) = e5 {
print("value = \(value)")
}
else {
// 由于e5的枚举值为value5而不是value1，
// 所以这里的case匹配就会失败，
// 走这里的else分支
print("Not matched!")
}
 
// 这里可通过逗号来做if语句所捕获关联值的进一步条件判断
if case let .value2(value) = e2, 
value > 5 {
print("value = \(value)")
}
 
// 如果我们要在一条if语句中连续捕获两个枚举关联值，
// 那么也可以使用逗号分隔，
// 并且每个表达式之前都需要加上case，
// 两个case条件之间的关系是“并且”的关系，
// 只要一个条件不满足，那么该if条件即为假。
// 最后也可以再次使用逗号做捕获关联值的进一步条件约束判断
if case let .value2(v) = e2,
case let .value3(x, y, z, w) = e3,
v > 5, x > 0.1 {
print("v = \(v), x = \(x)")
}

这种语法也是基于 if 语句以及 guard 语句的基础之上的，所以条件语句中所声明的对象的可见性也基于 if 语句与 guard 语句的语法特性。当然，由于Swift编程语言中， switch-case 语句也有许多丰富的匹配特性，所以这些也都能应用于对枚举关联值的捕获上，比如：

func furtherFetch(enum en: MyTestEnum) {
switch en {
case .value1(), .value5:
// 这里可以用逗号来分隔对多个case的匹配
print("empty tuple!")
 
case .value2(10 ..< 20):
// 这里限定了value2关联值的取值范围，
// 并且在此case分支中通过if语句进行捕获
if case let .value2(value) = en {
print("value2 = \(value)")
}
 
case .value2(var value) where value >= 50 && value <= 60:
// 这里同上述case类似，
// 不过我们可以直接声明对象对当前枚举关联值进行捕获，
// 然后通过where从句来验证关联值的匹配
value -= 20
print("value2 is: \(value)")
 
case .value2(let i) where i < 50,
.value3(1.0 ... 10.0, let i, (), "hello") where i > 10:
print("i = \(i)")
 default:
print("Not matched!")
break
}
}
 
// 输出：empty tuple!
furtherFetch(enum: e1)
furtherFetch(enum: e5)
 
// 输出：value2 = 10
furtherFetch(enum: e2)
 
// 这里匹配到最后一个case，
// 输出：i = 30
furtherFetch(enum: .value2(30))
 
// 输出：value2 is: 30
furtherFetch(enum: .value2(50))
 
// 输出：i = 20
furtherFetch(enum: .value3(1.5, 20, (), "hello"))
 
// 输出：Not matched!
furtherFetch(enum: .value2(100))

递归枚举

递归枚举也是与枚举关联值有关。如果一个枚举类型中某一枚举case的其中一个关联值的类型为该枚举类型本身，那么我们称之为递归枚举（recursive enumeration）。对于关联值包含自身枚举类型的一个枚举case，我们在声明该枚举case时需要在它前面添加 indirect 关键字，该关键字指示编译器在当前枚举case中插入一个间接层。我们也可以将 indirect 关键字添加到整个枚举类型之前，这样该枚举中的所有枚举case都被暗示插入间接层。我们看以下代码示例：

enum MyEnum {
 
/// 这里value1不指示对它插入间接层，
/// 因为其关联值不是该枚举类型本身
case value1(Int)
 
/// 对value2插入间接层，
/// 因为其关联值为该枚举类型本身
indirect case value2(MyEnum)
}
/// 这里在IndrectEnum枚举前直接添加indirect关键字，
/// 使得这里面所有的枚举case都插入了间接层。
/// 此时该枚举中的所有枚举case前都不能再放indirect关键字了
indirect enum IndrectEnum {
case value1(Int)
case value2(MyEnum)
}

下面我们看看递归枚举的使用情况。由于之前我们提到过，枚举类型是一种带有离散且有限个数值的类型，所以我们往往可以用枚举类型来实现一个有限状态机（Finite State Machine）。我们这里举一个简单的例子，各位也可以参考Apple官方的编程手册，里面也有一个比较详细的例子。

/// 这里定义了一个FoodAndDrink枚举
enum FoodAndDrink {
 
/// 名称
case name(String)
 
/// 吃
indirect case eat(FoodAndDrink)
/// 喝
indirect case drink(FoodAndDrink)
}
 
func treatFoodAndDrink(_ item: FoodAndDrink) {
 
switch item {
case .name(let str):
print(str)
 
case let .eat(food):
if case let .name(foodName) = food {
// 如果food是.name枚举值，那么我们这里获取其名称，
// 然后前面再添加eat这个动词
let newItem = FoodAndDrink.name("eat \(foodName)")
treatFoodAndDrink(newItem)
}
else {
print("Invalid food!")
}
 
case let .drink(drinks):
if case let .name(drinkName) = drinks {
// 如果这里drinks是.name枚举值，那么我们这里获取其名称，
// 然后前面添加drink这个动词
let newItem = FoodAndDrink.name("drink \(drinkName)")
treatFoodAndDrink(newItem)
}
else {
print("Invalid drink!")
}
}
}
 
let orange = FoodAndDrink.name("🍊")
let wine = FoodAndDrink.name("🍷")
 
// 这里的eatOrange用的是eat枚举case，
// 然后其关联值为orange这一FoodAndDrink的枚举对象
let eatOrange = FoodAndDrink.eat(orange)
 
// 这里的drinkWine用的是drink枚举case，
// 然后其关联值为wine这一FoodAndDrink的枚举对象
let drinkWine = FoodAndDrink.drink(wine)
// 这里的awfulCombination用的是drink枚举case，
// 然后其关联值为eatOrange这一FoodAndDrink的枚举对象
let awfulCombination = FoodAndDrink.drink(eatOrange)
 
// 输出：🍊
treatFoodAndDrink(orange)
 
// 输出：🍷
treatFoodAndDrink(wine)
 
// 输出：eat 🍊
treatFoodAndDrink(eatOrange)
 
// 输出：drink 🍷
treatFoodAndDrink(drinkWine)
 
// 输出：Invalid drink!
treatFoodAndDrink(awfulCombination)

枚举中的属性与方法

Swift编程语言中的枚举类型十分灵活，我们可以为其定义属性与方法，与结构体中的属性与方法类似。不过我们在枚举中不能为它定义存储式实例属性，其他的都可以。

/// 这里定义了一个MyEnum枚举
enum MyEnum {
 
case one(Int)
case two(Int)
case three(Int)
 
/// 在枚举中可以定义初始化器
init() {
// 这里默认将当前枚举对象的值作为one枚举值，
// 其关联值为0
self = .one(0)
}
/// 这里定义了一个实例方法fetchValue，
/// 用于萃取当前枚举值的关联值
func fetchValue() -> (Int, String) {
switch self {
case let .one(value):
return (value, "one")
 
case .two(let value):
return (value, "two")
 
case .three(let value):
return (value, "three")
}
}
 
/// 这里定义了一个类型方法，
/// 根据输入参数的值来返回相应的枚举值
static func makeEnum(with value: Int) -> MyEnum {
switch value {
case 0 ..< 10:
return .one(value)
 
case 20 ..< 30:
return .two(value)
 
default:
return .three(value)
}
}
 
/// 这里定义了一个计算式实例属性，
/// 将当前枚举值设置为two枚举值，
/// 并带有指定的关联值
var computedProperty: Int {
set(i) {
self = .two(i)
}
 
get {
return self.fetchValue().0
}
}
 
/// 这里定义了一个存储式类型属性
static var storedTypeProperty: Int = 100
 
/// 这里定义了一个计算式类型属性
static var comutedTypeProperty: Int {
set(i) {
storedTypeProperty = i
}
 
get {
return storedTypeProperty
}
}
}
 
func process(enum value: MyEnum) {
// 调用fetchValue实例方法
let (value, name) = value.fetchValue()
print("value = \(value), name is: \(name)")
}
 
// 调用MyEnum的类型方法makeEnum
process(enum: .makeEnum(with: 5))
process(enum: .makeEnum(with: 26))
process(enum: .makeEnum(with: -1))
 
// 这里使用MyEnum的初始化器构造一个对象实例
var e = MyEnum()
 
process(enum: e)
 
// 这里使用了MyEnum的计算式实例属性
e.computedProperty = 20
print("e = \(e), value = \(e.computedProperty)")
// 这里访问MyEnum的存储式类型属性
MyEnum.storedTypeProperty += 10
print("storedTypeProperty = \(MyEnum.storedTypeProperty)")
 
// 这里访问了MyEnum的计算式类型属性
MyEnum.comutedTypeProperty = 200
print("comutedTypeProperty = \(MyEnum.comutedTypeProperty)")
 
print("storedTypeProperty = \(MyEnum.storedTypeProperty)")

以上代码中我们可以看到，我们能利用枚举类型的实例方法来对当前的枚举值进行修改。我们也能定义枚举类型的初始化器来确定当前枚举对象的枚举值。