Controllo degli accessi

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

L'incapsulamento significa che un tipo controlla come possono essere utilizzati i suoi dati. Il controllo degli accessi decide chi può vedere una proprietà o un metodo. Contrassegnare un membro come private lo nasconde a tutto il codice esterno al tipo (e alle sue estensioni nello stesso file):

struct Account {
    private var balance = 0

    mutating func deposit(_ amount: Int) {
        balance += amount
    }
}

var a = Account()
a.deposit(50)
// a.balance = 1_000_000   // errore: 'balance' non è accessibile a causa del livello di protezione 'private'

Il codice esterno può quindi usare solo ciò che il tipo offre. Il tipo può controllare ogni modifica, così i suoi dati non finiscono mai in uno stato non consentito dal tipo:

struct Account {
    private var balance = 0

    mutating func deposit(_ amount: Int) {
        if amount > 0 { balance += amount }
    }

    func report() -> String {
        "balance: \(balance)"
    }
}

var a = Account()
a.deposit(50)
a.deposit(-999)
print(a.report())

Output:

balance: 50

Swift ha cinque livelli di accesso. Senza una parola chiave, un membro è internal: visibile ovunque nello stesso modulo (la tua app o il tuo pacchetto). I livelli dal più aperto al più ristretto:

open        // gli altri moduli possono usarlo e crearne sottoclassi (solo classi)
public      // gli altri moduli possono usarlo
internal    // impostazione predefinita: l'intero modulo
fileprivate // solo questo file sorgente
private     // questo tipo (e le sue estensioni nel file)

I metodi di supporto privati mantengono ridotta l'interfaccia pubblica: chi li usa vede cosa fa il tipo, non come lo fa.

struct Password {
    private let text: String

    init(_ text: String) { self.text = text }

    var isStrong: Bool {
        hasDigit() && text.count >= 8
    }

    private func hasDigit() -> Bool {
        text.contains { $0.isNumber }
    }
}

print(Password("secret123").isStrong)
print(Password("short1").isStrong)

Output:

true
false

Sfida

Facile

Completa la struct Locker. Il suo code e i suoi items sono private. store(_:code:) aggiunge un elemento solo quando il codice corrisponde e restituisce un valore che indica se è stato aggiunto; items(code:) restituisce gli elementi memorizzati uniti con , (oppure empty) quando il codice corrisponde, e wrong code altrimenti.

Il codice fornito legge il codice della cassetta e poi i comandi put <code> <item> oppure open <code>. Stampa stored o denied per ogni put, e il risultato per ogni open.

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

Provalo tu

// Supplied input/output code: keep it as it is
var input: [String] = []
while let line = readLine() { input.append(line) }
var locker = Locker(code: input[0])
for cmd in input.dropFirst() {
    let p = cmd.split(separator: " ").map(String.init)
    if p[0] == "put" {
        print(locker.store(p[2], code: p[1]) ? "stored" : "denied")
    } else {
        print(locker.items(code: p[1]))
    }
}