Swift Language
Enums

Uwagi

Podstawowe wyliczenia

Wyliczenie zapewnia zestaw powiązanych wartości:

enum Direction {
    case up
    case down
    case left
    case right
}

enum Direction { case up, down, left, right }

Wartości wyliczeniowych mogą być używane przez ich w pełni kwalifikowaną nazwę, ale można pominąć nazwę typu, gdy można ją wywnioskować:

let dir = Direction.up
let dir: Direction = Direction.up
let dir: Direction = .up

// func move(dir: Direction)...
move(Direction.up)
move(.up)

obj.dir = Direction.up
obj.dir = .up

Najbardziej podstawowym sposobem porównywania / wyodrębniania wartości wyliczania jest switch instrukcji switch :

switch dir {
case .up:
    // handle the up case
case .down:
    // handle the down case
case .left:
    // handle the left case
case .right:
    // handle the right case
}

Proste Hashable są automatycznie Hashable , Equatable i mają konwersje ciągów znaków:

if dir == .down { ... }

let dirs: Set<Direction> = [.right, .left]

print(Direction.up)  // prints "up"
debugPrint(Direction.up)  // prints "Direction.up"

Wyliczenia z powiązanymi wartościami

Przypadki wyliczeniowe mogą zawierać co najmniej jeden ładunek ( powiązane wartości ):

enum Action {
    case jump
    case kick
    case move(distance: Float)  // The "move" case has an associated distance
}

Podczas tworzenia wartości wyliczeniowej należy podać ładunek:

performAction(.jump)
performAction(.kick)
performAction(.move(distance: 3.3))
performAction(.move(distance: 0.5))

Instrukcja switch może wyodrębnić powiązaną wartość:

switch action {
case .jump:
    ...
case .kick:
    ...
case .move(let distance):  // or case let .move(distance):
    print("Moving: \(distance)") 
}

Wyodrębnienie pojedynczej skrzynki można wykonać, używając if case :

if case .move(let distance) = action {
    print("Moving: \(distance)") 
}

Składni guard case można użyć do późniejszego wyodrębnienia:

guard case .move(let distance) = action else {
    print("Action is not move")
    return
}

Domyślnie wyliczenia z powiązanymi wartościami nie są Equatable . Implementacja operatora == musi być wykonana ręcznie:

extension Action: Equatable { }

func ==(lhs: Action, rhs: Action) -> Bool {
    switch lhs {
    case .jump: if case .jump = rhs { return true }
    case .kick: if case .kick = rhs { return true }
    case .move(let lhsDistance): if case .move (let rhsDistance) = rhs { return lhsDistance == rhsDistance }
    }
    return false
}

Pośrednie ładunki

Zazwyczaj wyliczenia nie mogą być rekurencyjne (ponieważ wymagałyby nieskończonego przechowywania):

enum Tree<T> {
    case leaf(T)
    case branch(Tree<T>, Tree<T>)  // error: recursive enum 'Tree<T>' is not marked 'indirect'
}

indirect słowo kluczowe powoduje, że enum przechowuje swój ładunek z warstwą pośrednią, zamiast przechowywać go w linii. Możesz użyć tego słowa kluczowego w jednym przypadku:

enum Tree<T> {
    case leaf(T)
    indirect case branch(Tree<T>, Tree<T>)
}

let tree = Tree.branch(.leaf(1), .branch(.leaf(2), .leaf(3)))

indirect działa również na cały wyliczenie, czyniąc każdy przypadek pośrednim, gdy jest to konieczne:

indirect enum Tree<T> {
    case leaf(T)
    case branch(Tree<T>, Tree<T>)
}

Wartości Raw i Hash

Wyliczenia bez ładunków mogą mieć surowe wartości dowolnego typu dosłownego:

enum Rotation: Int {
    case up = 0
    case left = 90
    case upsideDown = 180
    case right = 270
}

Wyliczenia bez określonego typu nie ujawniają właściwości rawValue

enum Rotation {
    case up
    case right
    case down
    case left
}

let foo = Rotation.up
foo.rawValue //error

Zakłada się, że surowe wartości całkowite zaczynają się od 0 i rosną monotonicznie:

enum MetasyntacticVariable: Int {
    case foo  // rawValue is automatically 0
    case bar  // rawValue is automatically 1
    case baz = 7
    case quux  // rawValue is automatically 8
}

Nieprzetworzone wartości ciągów mogą być syntetyzowane automatycznie:

enum MarsMoon: String {
    case phobos  // rawValue is automatically "phobos"
    case deimos  // rawValue is automatically "deimos"
}

Wyliczanie wartości surowej automatycznie dostosowuje się do RawRepresentable . Możesz uzyskać odpowiednią wartość surową wartości .rawValue pomocą .rawValue :

func rotate(rotation: Rotation) {
    let degrees = rotation.rawValue
    ...
}

Możesz także utworzyć wyliczenie z wartości surowej za pomocą init?(rawValue:) :

let rotation = Rotation(rawValue: 0)  // returns Rotation.Up
let otherRotation = Rotation(rawValue: 45)  // returns nil (there is no Rotation with rawValue 45)

if let moon = MarsMoon(rawValue: str) {
    print("Mars has a moon named \(str)")
} else {
    print("Mars doesn't have a moon named \(str)")
}

Jeśli chcesz uzyskać wartość skrótu określonego wyliczenia, możesz uzyskać dostęp do jego wartości skrótu. Wartość skrótu zwróci indeks wyliczenia zaczynając od zera.

let quux = MetasyntacticVariable(rawValue: 8)// rawValue is 8
quux?.hashValue //hashValue is 3

Inicjatory

Wyliczenia mogą mieć niestandardowe metody inicjowania, które mogą być bardziej przydatne niż domyślna init?(rawValue:) . Wyliczenia mogą również przechowywać wartości. Może to być przydatne do przechowywania wartości, z których zostały zainicjowane, i późniejszego odzyskania tej wartości.

enum CompassDirection {
    case north(Int)
    case south(Int)
    case east(Int)
    case west(Int)

    init?(degrees: Int) {
        switch degrees {
        case 0...45:
            self = .north(degrees)
        case 46...135:
            self = .east(degrees)
        case 136...225:
            self = .south(degrees)
        case 226...315:
            self = .west(degrees)
        case 316...360:
            self = .north(degrees)
        default:
            return nil
        }
    }
    
    var value: Int = {
        switch self {
            case north(let degrees):
                return degrees
            case south(let degrees):
                return degrees
            case east(let degrees):
                return degrees
            case west(let degrees):
                return degrees
        }    
    }
}

Za pomocą tego inicjalizatora możemy to zrobić:

var direction = CompassDirection(degrees: 0) // Returns CompassDirection.north
direction = CompassDirection(degrees: 90) // Returns CompassDirection.east
print(direction.value) //prints 90
direction = CompassDirection(degrees: 500) // Returns nil

Wyliczenia mają wiele cech z klasami i strukturami

Wyliczenia w Swift są znacznie potężniejsze niż niektóre ich odpowiedniki w innych językach, takich jak C. Dzielą one wiele funkcji z klasami i strukturami , takimi jak definiowanie inicjatorów , właściwości obliczeniowych , metod instancji , zgodności protokołu i rozszerzeń .

protocol ChangesDirection {
    mutating func changeDirection()
}

enum Direction {
    
    // enumeration cases
    case up, down, left, right
    
    // initialise the enum instance with a case
    // that's in the opposite direction to another
    init(oppositeTo otherDirection: Direction) {
        self = otherDirection.opposite
    }
    
    // computed property that returns the opposite direction
    var opposite: Direction {
        switch self {
        case .up:
            return .down
        case .down:
            return .up
        case .left:
            return .right
        case .right:
            return .left
        }
    }
}

// extension to Direction that adds conformance to the ChangesDirection protocol
extension Direction: ChangesDirection {
    mutating func changeDirection() {
        self = .left
    }
}

var dir = Direction(oppositeTo: .down) // Direction.up

dir.changeDirection() // Direction.left

let opposite = dir.opposite // Direction.right

Zagnieżdżone wyliczenia

Możesz zagnieżdżać wyliczenia jeden w drugim, pozwala to na uporządkowanie hierarchicznych wyliczeń, aby były bardziej uporządkowane i przejrzyste.

enum Orchestra {
    enum Strings {
        case violin
        case viola
        case cello
        case doubleBasse
    }
    
    enum Keyboards {
        case piano
        case celesta
        case harp
    }
    
    enum Woodwinds {
        case flute
        case oboe
        case clarinet
        case bassoon
        case contrabassoon
    }
}

I możesz użyć tego w ten sposób:

let instrment1 = Orchestra.Strings.viola
let instrment2 = Orchestra.Keyboards.piano