Basic usage of enumerations
- Definition: Enumeration is simply a data type, but this data type only contains customized specific data. It is a collection of data with common characteristics.
enum Direction {
case north
case south
case east
case west
}
enum Direction {
case north,south,east,west
}
var dir = Direction.west
dir = Direction.east
dir = .north
print(dir) // north
switch dir {
case .north:
print("north")
case .south:
print("south")
case.east:
print("east")
case .west:
print("west")
}
Associated Values
- Sometimes it is useful to store the
枚举的成员值associated其他类型的值
enum Score {
case points(Int)
case grade(Character)
}
var score = Score.points(96)
score = Score.grade("A")
switch score {
case let .points(i):
print(i, "points")
case let .grade(i):
print("grade", i)
} // grade A
enum Date {
case digit(year: Int, month: Int, day: Int)
case string(String)
}
var date = Date.digit(year: 2022, month: 10, day: 14)
date = .string("2022-10-14")
switch date {
case .digit(let year, let month, let day):
print(year, month, day)
case let .string(value):
print(value)
}
- Let can also be changed to var if necessary
enum Password {
case number(Int, Int, Int, Int)
case gesture(String)
}
var pwd = Password.number(3, 5, 7, 8)
pwd = .gesture("123456")
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
- The default value that can be used by enumeration members
相同类型is pre-corresponded. This default value is called: original value
enum PokerSuit : Character {
case spade = "♠️"
case heart = "♥️"
case diamond = "♦️"
case club = "♣️"
}
var suit = PokerSuit.spade
print(suit)
print(suit.rawValue) // ♠️
print(PokerSuit.club.rawValue) // ♣️
enum Grade : String {
case perfect = "A"
case great = "B"
case good = "C"
case bad = "D"
}
print(Grade.perfect.rawValue) //A
print(Grade.great.rawValue) //B
print(Grade.good.rawValue) //C
print(Grade.bad.rawValue) //D
Note: The original value does not occupy the memory of the enumeration variable
Implicitly Assigned Raw Values
- If the original value type of the enumeration is Int or String , Swift will automatically assign the original value
enum Direction : String {
case north = "north"
case south = "south"
case east = "ease"
case west = "west"
}
//等价于
enum Direction :String {
case north, south, east, west
}
print(Direction.north) //north
print(Direction.north.rawValue) //north
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
Recursive enumerations must be preceded by indirect
indirect enum ArithExpr {
case number(Int)
case sum(ArithExpr, ArithExpr)
case difference(ArithExpr, ArithExpr)
}
//或者
enum ArithExpr {
case number(Int)
indirect case sum(ArithExpr, ArithExpr)
indirect case difference(ArithExpr, ArithExpr)
}
let five = ArithExpr.number(5)
let four = ArithExpr.number(4)
let two = ArithExpr.number(2)
let sum = ArithExpr.sum(five, four)
let difference = ArithExpr.difference(sum, two)
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(difference)
MemoryLayout
- You can use MemoryLayout to get the memory size occupied by the data type
enum Password {
case number (Int, Int, Int, Int)
case other
}
MemoryLayout<Password>.stride // 40, 分配占用的空间大小
MemoryLayout<Password>.size // 33, 时机用到的空间大小
MemoryLayout<Password>.alignment // 8, 对齐参数
var pwd = Password.number(9, 8, 6, 4)
pwd = .other
MemoryLayout.stride(ofValue: pwd) // 40
MemoryLayout.size(ofValue: pwd) // 33
MemoryLayout.alignment(ofValue: pwd) // 8
