Swift-枚举

【返回目录】

枚举

• 枚举定义
• 关联值（Associated Values）
• 原始值（Raw Values）
• 隐式原始值（Implicitly Assigned Raw Values）
• 递归枚举（Recursive Enumeration）
• MemoryLayout

• 定义

enum Direction {
    case north
    case south
    case east
    case west
}
var dir = Direction.west
dir = Direction.north
dir = .north
<br/>


switch dir {
    case .north:
        print("north")
    case .south:
        print("south")
    case .east:
        print("east")
    case .west:
        print("west")
}

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

enum Score {
    case points(Int)
    case grade(Character)
}
var score = Score.points(99)
score = .grade("A")

switch score {
    case let .points(i):
        print(i,"points")
    case let .grade(i):
        print(i,"points")
}

enum Date {
   case digit(year: Int, month: Int, day: Int)
   case string(String)
}

var date = Date.digit(year: 2023, month: 4, day: 14)
date = .string("2023-4-14")

switch date {
   case .digit(let year, let month, let day):
       print(year,month,day)
   case let .string(value):
       print(value)
}
//必要时let可以改为var

enum Password {
   case number(Int, Int, Int,Int)
   case gesture(String)
}
var pwd = Password.number(1, 2, 3, 4)
pwd = .gesture("1234")

switch pwd {
   case let .number(n1, n2, n3, n4):
       print("number is ",n1, n2, n3, n4)
   case let .gesture(str):
       print("gesture is \(str)")
}

• 原始值（Raw Values）
  枚举成员可以使用相同类型的默认值预先关联，这个默认值叫做“原始值”

enum Grade: String {
    case perfect = "A"
    case great = "B"
    case good = "C"
    case bad = "D"
}
print(Grade.perfect) // perfect
print(Grade.perfect.rawValue) // A

• 隐式原始值（Implicitly Assigned Raw Values）
  如果枚举的原始值类型是Int、String，Swift会自动分配原始值

// 以下两种写法是等价
enum Direction: String {
    case north = "north"
    case south = "south"
    case east = "east"
    case west = "west"
}

enum Direction：String {
    case north, south, east, west
}2

print(Direction.north)
print(Direction.north.rawValue)

enum Season: Int {
    case spring, summer, autumn, winter
}
print(Season.spring.rawValue) // 0
print(Season.summer.rawValue) // 1
print(Season.autumn.rawValue) // 2
print(Season.winter.rawValue) // 3

enum Season: Int {
    case spring = 1, summer, autumn = 4, winter
}
print(Season.spring.rawValue) // 1
print(Season.summer.rawValue) // 2
print(Season.autumn.rawValue) // 4
print(Season.winter.rawValue) // 5

• 递归枚举（Recursive Enumeration）
  使用递归枚举必须加上indirect关键字

enum ArithExpr {
    case number(Int)
    indirect case sum(ArithExpr, ArithExpr)
    indirect case difference(ArithExpr, ArithExpr)
}

//和上面写法等价，推荐使用这种写法
indirect enum ArithExpr {
    case number(Int)
    case sum(ArithExpr, ArithExpr)
    case difference(ArithExpr, ArithExpr)
}

let five = ArithExpr.number(5)
let four = ArithExpr.number(4)
let tow = ArithExpr.number(2)
let sum = ArithExpr.sum(five, four)
let difference = ArithExpr.difference(sum, tow)

//使用函数表达式
func calculate(_ expr: ArithExpr) -> Int {
    switch expr {
        case let .number(value):
            return value
        case let .sum(left, right):
            return calculate(left) + calculate(right)
        case let .difference(left, right):
            return calculate(left) - calculate(right)
    }
}
calculate(sum)

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

 var age = 10
 MemoryLayout<Int>.size // 占用字节
 MemoryLayout<Int>.stride //
 MemoryLayout<Int>.alignment //内存对齐

 MemoryLayout.size(ofValue: age)
 MemoryLayout.stride(ofValue: age)
 MemoryLayout.alignment(ofValue: age)

【上一篇】：函数
【下一篇】：可选项