Syntaxe de base Swift - énumération

Utilisation de base des énumérations

• Définition : L'énumération est simplement un type de données, mais ce type de données ne contient que des données spécifiques personnalisées. Il s'agit d'un ensemble de données ayant des caractéristiques communes.

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")
}

Valeurs associées

• Il est parfois utile de stocker les 枚举的成员值informations associées其他类型的值

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 peut également être modifié en var si nécessaire

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)
}

Valeurs brutes

• La valeur par défaut qui peut être utilisée par les membres de l'énumération 相同类型est pré-correspondante. Cette valeur par défaut est appelée : valeur d'origine

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

Remarque : La valeur d'origine n'occupe pas la mémoire de la variable d'énumération

Valeurs brutes implicitement attribuées

• Si le type de valeur d'origine de l'énumération est Int ou String , Swift attribuera automatiquement la valeur d'origine

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

Énumération récursive

Les énumérations récursives doivent être précédées d'une énumération indirecte.

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)

Disposition de la mémoire

• Vous pouvez utiliser MemoryLayout pour obtenir la taille de la mémoire occupée par le type de données

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