Control de acceso

Parte de la sección Programación orientada a objetos del Journey de Swift de Coddy. Lección 17 de 57.

La encapsulación significa que un tipo controla cómo se pueden utilizar sus datos. El control de acceso decide quién puede ver una propiedad o un método. Marcar un miembro como private lo oculta de todo el código que está fuera del tipo (y de sus extensiones en el mismo archivo):

struct Account {
    private var balance = 0

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

var a = Account()
a.deposit(50)
// a.balance = 1_000_000   // error: 'balance' es inaccesible debido al nivel de protección 'private'

El código externo solo puede usar lo que ofrece el tipo. El tipo puede comprobar cada cambio, por lo que sus datos nunca terminan en un estado que el tipo no permita:

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())

Salida:

balance: 50

Swift tiene cinco niveles de acceso. Sin una palabra clave, un miembro es internal: visible en todo el mismo módulo (tu aplicación o paquete). Los niveles, del más abierto al más restringido:

open        // otros módulos pueden usarlo y crear subclases de él (solo clases)
public      // otros módulos pueden usarlo
internal    // predeterminado: todo el módulo
fileprivate // solo este archivo fuente
private     // este tipo (y sus extensiones en el archivo)

Los métodos auxiliares privados mantienen pequeña la superficie pública: quienes llaman ven lo que hace el tipo, no cómo lo hace.

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)

Salida:

true
false

Desafío

Fácil

Completa la estructura Locker. Su code y items son private. store(_:code:) añade un elemento solo cuando el código coincide y devuelve si lo hizo; items(code:) devuelve los elementos almacenados unidos con , (o empty) cuando el código coincide, y wrong code en caso contrario.

El código proporcionado lee el código de la taquilla y después los comandos put <code> <item> u open <code>. Imprime stored o denied para cada put, y el resultado para cada open.

Tu código debe ir en Locker.swift. main.swift contiene el código proporcionado de entrada/salida y no se puede editar.

Pruébalo tú mismo

// Código de entrada/salida suministrado: mantenlo como está
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]))
    }
}