Swift Language
Enums

Anmärkningar

Grundläggande uppräkningar

Enum ger en uppsättning relaterade värden:

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

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

Enumvärden kan användas av deras fullt kvalificerade namn, men du kan utelämna typnamnet när det kan dras ut:

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

Det mest grundläggande sättet att jämföra / extrahera enumvärden är med ett switch uttalande:

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
}

Enkla enums är automatiskt Hashable , Equatable och har strängkonverteringar:

if dir == .down { ... }

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

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

Enums med tillhörande värden

Enumfall kan innehålla en eller flera nyttolaster ( tillhörande värden ):

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

Nyttolasten måste tillhandahållas vid inställning av enumvärdet:

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

switch kan extrahera tillhörande värde:

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

En extrahering av enskilda fall kan göras med if case :

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

Den guard case syntax kan användas för senare användning utvinning:

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

Enum med tillhörande värden är inte Equatable standard. Implementeringen av operatören == måste göras manuellt:

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
}

Indirekt nyttolast

Normalt kan enums inte vara rekursiva (eftersom de kräver oändlig lagring):

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

Det indirect nyckelordet gör att enum lagrar sin nyttolast med ett lager indirekt, snarare än att lagra det inline. Du kan använda detta nyckelord i ett enda fall:

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 fungerar också på hela enum, vilket gör alla fall indirekta vid behov:

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

Rå och Hash-värden

Enum utan nyttolast kan ha råvärden av vilken bokstavlig typ som helst:

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

Enum utan någon specifik typ exponerar inte egenskapen rawValue

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

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

Heltal råvärden antas börja vid 0 och öka monotont:

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

Råvaruvärden kan syntetiseras automatiskt:

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

En råvärderad enum överensstämmer automatiskt med RawRepresentable . Du kan få ett enumvärde motsvarande .rawValue med .rawValue :

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

Du kan också skapa en enum från ett råvärde med hjälp av 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)")
}

Om du vill få hashvärdet för ett specifikt enum kan du komma åt dess hashValue, hashvärdet kommer att returnera enumets index från noll.

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

Initializers

Enums kan ha anpassade initmetoder som kan vara mer användbara än standardinit init?(rawValue:) . Enums kan också lagra värden. Detta kan vara användbart för att lagra de värden som de initialiserades med och hämta det värdet senare.

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

Med den initialiseraren kan vi göra detta:

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

Uppräkningar delar många funktioner med klasser och strukturer

Enums i Swift är mycket kraftfullare än några av sina motsvarigheter på andra språk, till exempel C. De delar många funktioner med klasser och strukturer , såsom att definiera initialiserare , beräknade egenskaper , instansmetoder , protokollkonformationer och tillägg .

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

Kapslade uppräkningar

Du kan häcka uppräkningar i varandra, detta gör att du kan strukturera hierarkiska enum för att vara mer organiserade och tydliga.

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

Och du kan använda det så:

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