Enum con metodi

Fa parte della sezione Programmazione orientata agli oggetti del percorso Swift di Coddy. Lezione 15 di 57.

Un enum definisce un tipo con un insieme fisso di casi. I valori si scrivono con un punto e switch deve gestire ogni caso, quindi l’aggiunta di un caso in seguito mostra ogni punto che deve essere aggiornato:

enum Direction {
    case north, east, south, west
}

let heading = Direction.east
switch heading {
case .north: print("up")
case .east: print("right")
case .south: print("down")
case .west: print("left")
}

Output:

right

Le enumerazioni possono avere metodi e proprietà calcolate. Al loro interno, self è il caso corrente:

enum Direction {
    case north, east, south, west

    var turnedRight: Direction {
        switch self {
        case .north: return .east
        case .east: return .south
        case .south: return .west
        case .west: return .north
        }
    }
}

print(Direction.north.turnedRight)
print(Direction.west.turnedRight.turnedRight)

Output:

east
east

Un valore raw associa un valore fisso di un tipo a ciascun caso. init(rawValue:) funziona al contrario e restituisce nil quando non corrisponde a nessun caso:

enum Size: String {
    case small = "S", medium = "M", large = "L"
}

print(Size.medium.rawValue)
print(Size(rawValue: "L") == .large)
print(Size(rawValue: "XL") == nil)

Output:

M
true
true

I valori associati consentono a ogni caso di contenere i propri dati, permettendo a un tipo di contenere valori con strutture diverse. switch associa i dati con let:

enum Payment {
    case cash(amount: Int)
    case card(number: String, amount: Int)

    var amount: Int {
        switch self {
        case .cash(let amount): return amount
        case .card(_, let amount): return amount
        }
    }
}

let payments: [Payment] = [.cash(amount: 20), .card(number: "4242", amount: 55)]
print(payments.map { $0.amount })

Output:

[20, 55]

Sfida

Facile

Completa l'enum Command con i casi forward, back, left e right, associati ai valori grezzi F, B, L e R. Aggiungi una proprietà calcolata step che restituisce la variazione della posizione: avanti 1, indietro -1, a sinistra e a destra 0. Poi completa run(_:), che converte ogni carattere in un comando con init(rawValue:) (saltando i caratteri sconosciuti) e restituisce position 2, turns 1, skipped 1.

Il codice fornito legge una riga di lettere di comando e stampa il risultato di run(_:).

Il tuo codice va inserito in Command.swift e Functions.swift. main.swift contiene il codice di input/output fornito e non può essere modificato.

Provalo tu

// Codice di input/output fornito: mantienilo così com'è
var input: [String] = []
while let line = readLine() { input.append(line) }
print(run(input[0]))