En Swift, los métodos son funciones asociadas a un tipo. Los hay de tres categorías: de instancia (operan sobre self), de tipo (se llaman sobre el tipo mismo con static o class) y mutating (necesarios en structs y enums para modificar self porque son tipos por valor).
Métodos de instancia
struct Pila {
private var elementos: [T] = []
mutating func apilar(_ elemento: T) {
elementos.append(elemento)
}
mutating func desapilar() -> T? {
elementos.popLast()
}
func cima() -> T? { elementos.last }
var estaVacia: Bool { elementos.isEmpty }
}
var pila = Pila()
pila.apilar(1); pila.apilar(2); pila.apilar(3)
print(pila.desapilar()!) // 3
print(pila.cima()!) // 2
Métodos de tipo: static y class
static se usa en structs y enums (no se puede sobreescribir). class se usa en clases y sí se puede sobreescribir con override:
struct Temperatura {
var celsius: Double
static func deFahrenheit(_ f: Double) -> Temperatura {
Temperatura(celsius: (f - 32) * 5/9)
}
}
let t = Temperatura.deFahrenheit(212)
print(t.celsius) // 100.0
class Base {
class func fabrica() -> Base { Base() }
}
class Hija: Base {
override class func fabrica() -> Hija { Hija() }
}
mutating en enums
enum Semaforo {
case rojo, ambar, verde
mutating func siguiente() {
switch self {
case .rojo: self = .verde
case .verde: self = .ambar
case .ambar: self = .rojo
}
}
}
var s = Semaforo.rojo
s.siguiente()
print(s) // verde
Método que devuelve self (fluent API)
struct Consulta {
private var filtros: [String] = []
private var limite = 100
func filtrando(por campo: String) -> Consulta {
var c = self; c.filtros.append(campo); return c
}
func limitando(a n: Int) -> Consulta {
var c = self; c.limite = n; return c
}
var sql: String { "SELECT ... WHERE (filtros.joined(separator: " AND ")) LIMIT (limite)" }
}
let q = Consulta().filtrando(por: "activo=1").limitando(a: 10)
print(q.sql)







