Swift Language
Enums

Osservazioni

Enumerazioni di base

Un enum fornisce un insieme di valori correlati:

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

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

I valori Enum possono essere utilizzati dal loro nome completo, ma è possibile omettere il nome del tipo quando può essere desunto:

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

Il modo più fondamentale per confrontare / estrarre i valori enum è con un'istruzione 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
}

Le enumerazioni semplici sono automaticamente Hashable , Equatable e hanno conversioni di stringhe:

if dir == .down { ... }

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

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

Enum con valori associati

I casi Enum possono contenere uno o più payload ( valori associati ):

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

Il payload deve essere fornito durante l'istanziazione del valore enum:

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

L'istruzione switch può estrarre il valore associato:

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

Un'estrazione caso singolo può essere eseguita utilizzando il if case :

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

La sintassi del guard case può essere utilizzata per l'estrazione successiva:

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

Le enumerazioni con valori associati non sono Equatable per impostazione predefinita. L'implementazione dell'operatore == deve essere eseguita manualmente:

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
}

Carichi utili indiretti

Normalmente, le enumerazioni non possono essere ricorsive (perché richiederebbero una memoria infinita):

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

La parola chiave indirect rende l'enumerazione del carico utile con uno strato di riferimento indiretto, anziché memorizzarlo in linea. Puoi utilizzare questa parola chiave in un singolo caso:

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 funziona anche sull'intero enum, rendendolo comunque indiretto quando necessario:

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

Valori grezzi e hash

Le enumerazioni prive di payload possono avere valori non elaborati di qualsiasi tipo letterale:

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

Le enumerazioni senza alcun tipo specifico non espongono la proprietà rawValue

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

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

Si presuppone che i valori grezzi interi inizino a 0 e aumentino monotonicamente:

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

I valori raw delle stringhe possono essere sintetizzati automaticamente:

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

Un enum con valore grezzo si adatta automaticamente a RawRepresentable . Puoi ottenere il valore grezzo corrispondente di un valore enum con .rawValue :

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

Puoi anche creare un enum da un valore grezzo usando 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)")
}

Se si desidera ottenere il valore hash di un enum specifico, è possibile accedere al suo hashValue, il valore hash restituirà l'indice dell'enumerazione a partire da zero.

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

inizializzatori

Le enumerazioni possono avere metodi di inizializzazione personalizzati che possono essere più utili init?(rawValue:) default init?(rawValue:) . Le enumerazioni possono anche memorizzare valori. Questo può essere utile per memorizzare i valori con cui sono stati inizializzati e recuperare quel valore in seguito.

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

Usando quell'inizializzatore possiamo fare questo:

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

Le enumerazioni condividono molte funzionalità con classi e strutture

Enums in Swift sono molto più potenti di alcune delle loro controparti in altre lingue, come C. Condividono molte funzionalità con classi e strutture , come la definizione di inizializzatori , proprietà calcolate , metodi di istanza , conformità e estensioni del protocollo .

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

Enumerazioni nidificate

È possibile nidificare le enumerazioni una dentro l'altra, ciò consente di strutturare le enumerazioni gerarchiche per essere più organizzate e chiare.

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

E puoi usarlo in questo modo:

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