枚举的基本用法

  1. // 定义枚举
  2. enum Direction {
  3.     case north
  4.     case source
  5.     case east
  6.     case west
  7. }
  9. // 也可以写成
  10. enum Direction {
  11.     case north, source, east, west
  12. }

可以用于switch语句：

  1. let dir: Direction = .north
  2. switch dir {
  3. case .north:
  4.     print("north")
  5. case .source:
  6.     print("north")
  7. case .east:
  8.     print("north")
  9. case .west:
  10.     print("north")
  11. }

关联值（Associated Valuse）

有时会将枚举的成员值跟其他类型关联存储在一起，会非常有用

  1. // 分数举例
  2. enum Score {
  3.     case point(Int)
  4.     case grade(Character)
  5. }
  7. var s = Score.point(96)
  8. s = .grade("A")
  1. // 日期举例
  2. enum Date {
  3.     case digit(year: Int, month: Int, day: Int)
  4.     case string(String)
  5. }
  7. var date = Date.digit(year: 2018, month: 8, day: 8)
  8. date = .string("2018-8-8")
  10. switch date {
  11. case .digit(let year, let month, let day):
  12.     print(year, month, day)
  13. case let .string(value):
  14.     print(value)
  15. }

原始值（Raw Values）

枚举成员可以使用相同类型的默认值预先关联，这个默认值叫做：原始值

  1. enum direction: Int {
  2.     case left = 0
  3.     case right = 1
  4.     case up = 2
  5.     case down = 3
  6. }
  8. var dir = direction.left
  9. print(dir) // left
  10. print(dir.rawValue) // 0

隐式原始值（Implicitly Assigned Raw Values）

如果枚举的原始值是Int、String，Swift会自动分配原始值

  1. enum Direction: Int {
  2.     case north
  3.     case source
  4.     case east
  5.     case west
  6. }
  8. print(Direction.north.rawValue, Direction.source.rawValue) // 0 1
  1. enum Direction: String {
  2.     case north
  3.     case source
  4.     case east
  5.     case west
  6. }
  8. print(Direction.north.rawValue, Direction.source.rawValue) // north source

递归枚举

需要使用indirect关键字

  1. indirect enum ArithExpr {
  2.     case number(Int)
  3.     case sum(ArithExpr, ArithExpr)
  4.     case diffrence(ArithExpr, ArithExpr)
  5. }
  7. let five = ArithExpr.number(5)
  8. let four = ArithExpr.number(4)
  9. let sum = ArithExpr.sum(five, four)
  10. let diffrence = ArithExpr.diffrence(sum, four)

MemoryLayout

可以使用MemoryLayout获取数据类型所占内存大小

  1. // 获取类型所占内存
  2. MemoryLayout<Int>.size // 8
  3. MemoryLayout<Int>.stride // 8
  4. MemoryLayout<Int>.alignment // 8
  6. // 获取变量所占内存
  7. var age = 10
  8. MemoryLayout.size(ofValue: age) // 8
  9. MemoryLayout.stride(ofValue: age) // 8
  10. MemoryLayout.alignment(ofValue: age) // 8

获取枚举所占内存大小

  1. /// 带有关联值的枚举
  2. enum Password {
  3.     case number(Int, Int, Int, Int)
  4.     case other
  5. }
  7. let number = Password.number(1, 2, 3, 4)
  8. let other = Password.other
  10. MemoryLayout<Password>.size // 33，实际用到的空间大小
  11. MemoryLayout<Password>.stride // 40，分配战洪的空间大小
  12. MemoryLayout<Password>.alignment // 8，对齐参数
  1. enum Season: Int {
  2.     case spring, summer, autumn, winter
  3. }
  5. MemoryLayout<Season>.size // 1
  6. MemoryLayout<Season>.stride // 1
  7. MemoryLayout<Season>.alignment // 1

原始值不占用枚举变量的内存，占用内存的是spring.rawValue

  1. let s = Season.spring
  2. MemoryLayout.size(ofValue: s.rawValue) // 16
  3. MemoryLayout.stride(ofValue: s.rawValue) // 16
  4. MemoryLayout.alignment(ofValue: s.rawValue) // 8