枚举为一组相关的值定义了一个共同的类型，使你可以在你的代码中以类型安全的方式来使用这些值。
我们熟悉 的C 语言，枚举会为一组整型值分配相关联的名称。Swift 中的枚举更加灵活，不必给每一个枚举成员提供一个值。如果给枚举成员提供一个值（称为原始值），则该值的类型可以是字符串、字符，或是一个整型值或浮点数。
此外，枚举成员可以指定任意类型的关联值存储到枚举成员中，就像其他语言中的联合体（unions）和变体（variants）。你可以在一个枚举中定义一组相关的枚举成员，每一个枚举成员都可以有适当类型的关联值。
在 Swift 中，枚举类型是一等（first-class）类型。它们采用了很多在传统上只被类（class）所支持的特性，例如计算属性（computed properties），用于提供枚举值的附加信息；实例方法（instance methods），用于提供和枚举值相关联的功能；枚举也可以定义构造函数（initializers）来提供一个初始值；可以在原始实现的基础上扩展它们的功能；还可以遵循协议（protocols）来提供标准的功能。
一、枚举语法
Swift 中，枚举支持Int、Double、String等基础类型，也有默认枚举值（String类型默认枚举值为case的key名称，Int、Double数值型默认枚举值为0开始，+1递增。
代码：
// 写法一
// 不需要逗号隔开
enum Weak1 {
case MON
case TUE
case WED
case THU
case FRI
case SAT
case SUN
}
// 写法二
// 也可以直接一个case，然后使用逗号隔开
enum Weak2 {
case MON, TUE, WED, THU, FRI, SAT, SUN
}
// 定义一个枚举变量
var w: Weak1 = .MON
/*
String类型的enum
- =左边的值是枚举值，例如 MON
- =右边的值在swift中称为 RawValue（原始值），例如 "MON"
- 两者的关系为：case 枚举值 = rawValue原始值
*/
enum Week: String{
case MON = "MON"
case TUE = "TUE"
case WED = "WED"
case THU = "THU"
case FRI = "FRI"
case SAT = "SAT"
case SUN = "SUN"
}
如果不想写枚举值后的字符串，也可以使用隐式RawValue分配。
enum Week: String{
case MON, TUE, WED, THU, FRI, SAT, SUN
}
var w = Week.MON.rawValue
print(w)
//打印结果：MON
1.2 枚举的访问
那么Swift是如何获取rawValue的值，我们可以通过SIL文件分析。
SIL命令：
swiftc -emit-sil main.swift |xcrun swift-demangle >> ./main.sil && open main.sil
SIL文件
enum Week : String {
case MON, TUE, WED, THU, FRI, SAT, SUN
init?(rawValue: String) //默认添加了一个可选类型的init方法
typealias RawValue = String //给枚举值的类型，通过typealias取了一个别名RawValue
var rawValue: String { get } //增加一个计算属性rawValue，用于获取枚举值的原始值
}
main函数流程：
rawValue的getter方法：
bb8代码段：
总结：
rawValue的底层就是调用的getter方法，getter方法中构造了字符串，但是这个字符串的值（例如“MON”）从哪里取出的呢？他们在编译期已经确定了，我们查看Mach-O，在TEXT的__cstring段就能看到。
1.3 case枚举值 & rawValue原始值
代码：
//输出 case枚举值
print(Week.MON)
//输出 rawValue
print(Week.MON.rawValue)
//打印结果：MON MON
从结果来看是没有什么区别的，输出值都一样，但他们本质是不一样的。
第一个，输出的case枚举值；第二个，是通过rawValue访问的rawValue的get方法。
下面这种写法，编译器就会报错：
1.4 枚举的init
枚举的init会在什么时候调用，我们通过断点看一下：
①，不设置
Condition，进不到方法里面；②原生代码第一个断点，进入的是getter方法，进不去init。
即，
enum中init方法的调用是通过枚举.init(rawValue:）或者枚举(rawValue:）触发的。
继续：
print(Week.init(rawValue: "MON"))
print(Week.init(rawValue: "Hello"))
//打印结果：
//Optional(_6_EnumTest.Week.MON)
//nil
第一个输出的可选值，第二个输出的是nil。表示，没有找到对应的case枚举值。
分析SIL文件中的Week.init方法，主要有以下几步：
1、在init方法中是将所有enum的字符串从Mach-O文件中取出，依次放入数组中；
2、放完后，然后调用_findStringSwitchCase方法进行匹配。
如下：
index_addr：表示获取当前数组中的第n个元素值的地址，然后再把构建好的字符串放到当前地址中
struct_extract：表示取出当前的Int值，Int类型在系统中也是结构体
cond_br：表示比较的表达式，即分支条件跳转
- 如果匹配成功，则构建一个 .some的Optional 返回
- 如果匹配不成功，则继续匹配，知道最后还是没有匹配上，则构建一个.none的Optional返回
_findStringSwitchCase在swift-source中，接收两个参数，分别是 数组 + 需要匹配的String。①遍历数组，如果匹配则返回对应的index；②如果不匹配，则返回-1。
所以，这也是为什么一个打印可选值，一个打印nil的原因。
1.5枚举的遍历
CaseIterable协议通常用于没有关联值的枚举，用来访问所有的枚举值，只需要对应的枚举遵守该协议即可，然后通过allCases获取所有枚举值，如下：
// Double类型
enum Week1: Double, CaseIterable {
case Mon,Tue, Wed, Thu, Fri, Sat, Sun
}
Week1.allCases.forEach { print($0.rawValue)}
// String类型
enum Week2: String {
case Mon,Tue, Wed, Thu, Fri, Sat, Sun
}
extension Week2: CaseIterable {}
Week2.allCases.forEach { print($0.rawValue)}
二、关联值枚举、模式匹配、属性方法
如果希望用枚举表示复杂的含义，关联更多的信息，就需要使用关联值了。
他与普通类型的枚举
不同：没有rawValue，没有rawValue的getter方法；没有初始化init方法。
//注：当使用了关联值后，就没有RawValue了
//因为：case可以用一组值来表示，而rawValue是单个的值
enum Shape{
//case枚举值后括号内的就是关联值，如 radius
case circle(radius: Double)
case rectangle(width: Int, height: Int)
}
//创建
var circle = Shape.circle(radius: 10.0)
//重新分配
circle = Shape.rectangle(width: 10, height: 10)
模式匹配
enum中的模式匹配其实就是匹配case枚举值，根据枚举类型，分为2种：
1、简单类型的枚举的模式匹配；
2、自定义类型的枚举（关联值）的模式匹配。
简单enum的模式匹配
注：swift中的enum模式匹配需要将所有情况都列举，或者使用default表示默认情况，否则会报错
enum Week: String{
case MON
case TUE
case WED
case THU
case FRI
case SAT
case SUN
}
var current: Week?
switch current {
case .MON: print(Week.MON.rawValue)
case .TUE: print(Week.MON.rawValue)
default:print("unknow day")
}
//打印结果：unknow day
关联值类型的模式匹配
关联值类型的模式匹配有两种方式：1、switch - case， 匹配所有case；2、if - case， 匹配单个case。
switch - case
定义关联值枚举：
enum Shape{
case circle(radius: Double)
case rectangle(width: Int, height: Int)
}
可以let var修饰关联值的入参：
let shape = Shape.circle(radius: 10.0)
switch shape{
//相当于将10.0赋值给了声明的radius常量
case let .circle(radius):
print("circle radius: \(radius)")
case .rectangle(let width, var height):
height += 1
print("rectangle width: \(width) height: \(height)")
}
- 通过
if-case匹配单个case，如下：
let circle = Shape.circle(radius: 10)
//匹配单个case
if case let Shape.circle(radius) = circle {
print("circle radius: \(radius)")
}
- 如果我们只关心
不同case的相同关联值(即关心不同case的某一个值)，需要使用同一个参数。
例如，案例中的x，如果分别使用x、y, 编译器会报错：
enum Shape{
case circle(radius: Double)
case rectangle(width: Double, height: Double)
case square(width: Double, height: Double)
}
let shape = Shape.circle(radius: 10)
switch shape{
case let .circle(x), let .square(20, x):
print(x)
default:
break
}
也可以使用通配符_（表示匹配一切）的方式：
let shape = Shape.rectangle(width: 10, height:20)
switch shape{
case let .rectangle(x, _), let .square(_, x):
print("x = \(x)")
default:
break
}
注：枚举使用过程中不关心某一个关联值，可以使用通配符_表示。OC只能调用swift中Int类型的枚举。
属性 & 函数
enum中可以包含计算属性、类型属性，不能包含存储属性。
enum Direct: Int {
case up
case down
case left
case right
// 计算型属性
var description: String{
switch self {
case .up:
return "这是上面"
default:
return "这是\(self)"
}
}
//存储属性：编译器报错，Enums must not contain stored properties
//var radius: Double
//类型属性 - 是一个全局变量
static let height = 20.0
// 函数
func printSelf() {
print(description)
}
mutating func nextDay(){
if self == .up{
self = Direct(rawValue: 1)!
}else{
self = Direct(rawValue: self.rawValue+1)!
}
}
}
Direct.down.printSelf()
//打印结果：这是down
var direct = Direct.left;
direct.nextDay();
direct.printSelf()
//打印结果：这是right
为什么
struct中可以放存储属性，而enum不可以？
struct中可以包含存储属性，是因为其大小就是存储属性的大小。而enum是不一样的（请查阅后文的enum大小讲解），enum枚举的大小是取决于case的个数的，如果没有超过255，enum的大小就是1字节（8位）
可以在enum中定义实例方法、static修饰的方法：
enum Week: Int{
case MON, TUE, WED, THU, FRI, SAT, SUN
mutating func nextDay(){
if self == .SUN{
self = Week(rawValue: 0)!
}else{
self = Week(rawValue: self.rawValue+1)!
}
}
}
var w = Week.MON
w.nextDay()
print(w)
三、枚举的嵌套
枚举的嵌套主要用于以下场景：
1、枚举嵌套枚举：一个复杂枚举是由一个或多个枚举组成；
2、结构体嵌套枚举：enum是不对外公开的，即是私有的。
3.1 enum嵌套enum
枚举嵌套枚举，改动上面的例子：
enum CombineDirect{
//枚举中嵌套的枚举
enum BaseDirect{
case up
case down
case left
case right
}
//通过内部枚举组合的枚举值
case leftUp(baseDIrect1: BaseDirect, baseDirect2: BaseDirect)
case leftDown(baseDIrect1: BaseDirect, baseDirect2: BaseDirect)
case rightUp(baseDIrect1: BaseDirect, baseDirect2: BaseDirect)
case rightDown(baseDIrect1: BaseDirect, baseDirect2: BaseDirect)
}
//使用
let leftUp = CombineDirect.leftUp(baseDIrect1: CombineDirect.BaseDirect.left, baseDirect2: CombineDirect.BaseDirect.up)
结构体嵌套枚举
//结构体嵌套枚举
struct Skill {
enum KeyType{
case up
case down
case left
case right
}
let key: KeyType
func launchSkill(){
switch key {
case .left, .right:
print("left, right")
case .up, .down:
print("up, down")
}
}
}
枚举的递归：indirect
递归枚举是一种枚举类型，它有一个或多个枚举成员使用该枚举类型的实例作为关联值。使用递归枚举时，编译器会插入一个间接层。你可以在枚举成员前加上 indirect 来表示该成员可递归。
//一、用枚举表示链表结构
enum List{
case end
//表示case使是引用来存储
indirect case node(T, next: List)
}
//二、也可以将indirect放在enum前
//表示整个enum是用引用来存储
indirect enum List{
case end
case node(T, next: List)
}
第一种写法，如果没有关键字indirect，编译报错。原因是使用该枚举时，enum的大小需要case来确定，而case的大小又需要使用到enum大小。所以无法计算enmu的大小，于是报错！
根据编译器提示，需要使用关键字indirect，意思就是将该枚举标记位递归，同时也支持标记单个case。
enum内存大小：
enum List{
case end
indirect case node(T, next: List)
}
print(MemoryLayout.size)
print(MemoryLayout>.size)
print(MemoryLayout>.stride)
print(MemoryLayout.size)
print(MemoryLayout>.size)
print(MemoryLayout>.stride)
//打印结果：
//8 8 8
//16 8 8
发现Int、String都是8。为什么？
下面通过LLDB分析查看一下：
如果是end，此时存储的是case值，为0，而case为node时存储的是引用地址。
所以，
indirect关键字其实就是通知编译器，我当前的enum是递归的，大小是不确定的，需要分配一块堆区的内存空间，用来存放enum。
四、swift和OC混编enum
在swift中，enum非常强大，而在OC中，enum仅仅只是一个整数值。
因此，OC调用Swift枚举，必须具备2个条件：①、用@objc关键字标记enum；②、当前enum应该是Int类型。
// Swift中定义枚举
@objc enum Weak: Int{
case MON, TUE, WED, THU, FRI, SAT, SUN
}
// OC使用
- (void)test{
Weak mon = WeakMON;
}
Swift使用OC枚举，OC中的枚举会自动转换成swift中的enum。
// OC定义1：NS_ENUM
NS_ENUM(NSInteger, ENUM_OC_TYPE){
Value1,
Value2
};
// OC定义2：typedef enum
typedef enum {
Num1,
Num2
}OCEnumType;
// swift使用
//1、将OC头文件导入桥接文件xxx-Bridging-Header.h
#import "xxx.h"
//2、使用
let ocEnum1 = ENUM_OC_TYPE.Value1
let ocEnum2 = OCEnumType.init(0)
print("\(ocEnum1) + \(ocEnum2.rawValue)")
//打印结果：ENUM_OC_TYPE + 0
上图可知，通过
typedef enum定义的enum，在swift中变成了一个结构体，并遵循了两个协议：Equatable 和 RawRepresentable。
OC使用Swift中String类型的枚举方式
@objc enum Weak: Int{
case MON, TUE, WED
var val: String?{
switch self {
case .MON:
return "MON"
case .TUE:
return "TUE"
case .WED:
return "WED"
default:
return nil
}
}
}
// OC中使用
Weak mon = WeakMON;
// swift中使用
let weak = Weak.MON.val
即：swift中的enum成Int整型；enum再声明一个变量/方法，用于返回固定的字符串，用于在swift中使用。
五、Enum内存大小
我们主要分析两个函数的区别：
-
size：实际占用内存大小； -
stride：系统分配的内存大小。
5.1 普通enum
一个case的情况：
enum Weak {
case MON
//case TUE
}
print(MemoryLayout.size)
print(MemoryLayout.stride)
//打印结果：0 1
再加一个case：
enum Weak {
case MON
case TUE
}
print(MemoryLayout.size)
print(MemoryLayout.stride)
//打印结果：1 1
继续增加多个case：
enum Weak {
case MON
case TUE
case WED
case THU
case FRI
case SAT
case SUN
}
print(MemoryLayout.size)
print(MemoryLayout.stride)
//打印结果：1 1
以上可以看出，当case个数为1时，枚举size为0，个数>=2时，size的大小始终是1，即，说明enum就是以1字节存储在内存中的。why？
读取内存可以看出，
case都是1字节大小，1个字节是8个byte，那么有255种排列组合(0x00000000 - 0x11111111)。
所以，
当case为1个的时候，size的大小是0（二进制是0x0）；case数<=255时，size都是1，是UInt8类型。
超过255个时，会自动扩容，size和stride都会增加。
总结：
1、如果enum中有原始值，即rawValue，其大小取决于case的多少，如果没有超过UInt8即255，则就是1字节存储case，Int标识的其实就是RawValue的值。
2、当只有一个case的情况下，size是0，表示这个enum是没有意义的。
3、当有两个及以上case时，如果没有超过255，则case的步长是1字节；如果超过，则UInt8->UInt16...，以此类推。
5.2 关联值的enum
自定义类型的枚举，即关联值类型，size和stride值的变化，如下：
enum Shape{
case circle(radius: Double)
case rectangle(width: Double, height: Double)
}
print(MemoryLayout.size)
print(MemoryLayout.stride)
//打印结果：17 24
分析：
-
case(枚举值)size是1； - 枚举是
共用内存，有关联值时，取最大值；
2.1circle的参数是double类型，内存size是8；
2.2rectangle的参数是两个double类型，内存size是16； - 取
最大值，为16。即，内存size为：16(最大关联值大小) + 1(case枚举值）= 17。 -
内存对齐，所以stride为24。
断点读取内存验证一下：image.png
5.3 enum嵌套enum
enum CombineDirect{
enum BaseDirect{
case up, down, left, right
}
case leftUp(baseDirect1: BaseDirect, baseDirect2: BaseDirect)
case rightUp(baseDirect1: BaseDirect, baseDirect2: BaseDirect)
case leftDown(baseDirect1: BaseDirect, baseDirect2: BaseDirect)
case rightDown(baseDirect1: BaseDirect, baseDirect2: BaseDirect)
}
print(MemoryLayout.size)
print(MemoryLayout.stride)
//打印结果：2 2
说明：enum嵌套enum同具有关联值的enum是一样的，同样取决于关联值的大小，其内存大小是最大关联值的大小。
定义一个变量，观察一下内存：
var combine = CombineDirect.leftDown(baseDirect1: .left, baseDirect2: .down)
总结，有待进一步验证：
enum嵌套enum同样取决于最大case的关联值大小；
当嵌套enum的case只有2个时，case在内存中的存储是0、8；
当嵌套enum的case大于2，小于等于4时，case在内存中的存储是 0、4、8、12；
当嵌套enum的case大于4时，case在内存中的存储是从0、1、2...以此类推。
5.4 结构体嵌套enum
struct Skill {
enum KeyType{
case up
case down
case left
case right
}
}
print(MemoryLayout.size)
print(MemoryLayout.stride)
//打印结果：0 1
如果只嵌套了enum，没有声明变量。size的大小取决于成员变量，但是struct中目前没有属性，所以size是1。
struct Skill {
enum KeyType{
case up
case down
case left
case right
}
let key: KeyType
func launchSkill(){
switch key {
case .left, .right:
print("left, right")
case .up, .down:
print("up, down")
}
}
}
print(MemoryLayout.size)
print(MemoryLayout.stride)
//打印结果：1 1
结构体的大小计算，跟函数无关，所以只看成员变量key的大小，key是枚举Skill类型，大小为1，所以结构体大小为1。
如果在添加一个成员变量：
struct Skill {
enum KeyType{
case up
case down
case left
case right
}
let key: KeyType //1字节
var height: UInt8 //1字节
func launchSkill(){
switch key {
case .left, .right:
print("left, right")
case .up, .down:
print("up, down")
}
}
}
print(MemoryLayout.size)
print(MemoryLayout.stride)
//打印结果：2 2
在添加一个Int属性：
struct Skill {
enum KeyType{
case up
case down
case left
case right
}
let key: KeyType //1字节
var height: UInt8 //1字节
var width: Int //8字节
func launchSkill(){
switch key {
case .left, .right:
print("left, right")
case .up, .down:
print("up, down")
}
}
}
print(MemoryLayout.size)
print(MemoryLayout.stride)
//打印结果：16 16
//打印结果2：如果把Int属性放在最前面，则为，10 16
为什么属性位置不一样，打印结果不一样，也是因为内存对齐。内存对齐规则如下：
/**
数据成员的对齐规则可以理解为min(m, n) 的公式
m，表示当前成员的开始位置；n，表示当前成员所需要的位数。
如果满足条件 m 整除 n （即 m % n == 0）, n 从 m 位置开始存储；
反之继续检查 m+1 能否整除 n, 直到可以整除, 从而就确定了当前成员的开始位置。
*/
struct Mystruct4{
int a; //4字节 min（0，4）--- （0，1，2，3）
struct Mystruct5{ //从4开始，存储开始位置必须是最大的整数倍（最大成员为8），min（4，8）不符合 4，5，6，7，8 -- min（8，8）满足，从8开始存储
double b; //8字节 min(8,8) --- (8,9,10,11,12,13,14,15)
short c; //1字节,从16开始，min（16，1） -- （16，17）
}Mystruct5;
}Mystruct4;
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSLog(@"%lu %lu", sizeof(Mystruct4), sizeof(Mystruct4.Mystruct5));
//打印结果：24 16
NSLog(@"Hello, World!");
}
return 0;
}
结构体嵌套了enum总结：
1、如果没有声明变量，此时的size是0，stride是1；
2、如果结构体中没有其他属性，只有枚举变量，那么结构体的大小就是枚举的大小，即size为1；
3、如果结构体中还有其他属性，则按照OC中的结构体内存对齐原则进行分析。
内存对齐 & 字节对齐 区分
内存对齐：iOS中是8字节对齐，苹果实际分配采用16字节对齐，这种只会在分配对象时出现。
字节对齐：存储属性的位置必须是偶地址，即OC内存对齐中的min(m，n)，其中m表示存储的位置，n表示属性的大小，需要满足位置m整除n时，才能从该位置存放属性。简单来说，就是必须在自身的倍数位置开始。
外部调用对象时，对象是服从内存对齐。
单纯从结构上说，结构内部服从最大字节对齐。即，枚举size为1的情况。
总结：
一、枚举定义:
1、enum中使用rawValue的本质是调用get方法，即在get方法中从Mach-O对应地址中取出字符串并返回的操作；
2、enum中init方法的调用是通过枚举.init(rawValue:）或者枚举(rawValue:）触发的；
3、没有关联值的enum，如果希望获取所有枚举值，需要遵循CaseIterable协议，然后通过枚举名.allCase的方式获取；
4、case枚举值和rawValue原始值的关系：case 枚举值 = rawValue原始值；
5、具有关联值的枚举，可以称为三无enum，因为没有别名RawValue、init、计算属性rawValue；
6、enum的模式匹配方式，主要有两种：switch-case/if-case
7、enum可以嵌套enum，也可以在结构体中嵌套enum，表示该enum是struct私有的；
8、enum中还可以包含计算属性、类型属性，但是不能包含存储属性；
9、enum中可以定义实例、static修饰的方法。
二、枚举内存：
1、普通enum的内存大小一般是1字节，如果只有一个case，则为0，表示没有意义，如果case个数超过255，则枚举值的类型由UInt8->UInt16->UInt32...；
2、具有关联值的enum大小，取决于最大case的内存大小+case的大小（1字节）；
3、enum嵌套enum同样取决于最大case的关联值大小；
4、结构体嵌套enum，如果没有属性，则size为0，如果只有enum属性，size为1，如果还有其他属性，则按照OC中内存对齐原则进行计算。
参考：枚举教程