PROTOCOLOS en Swift en Español - Curso Swift | Tutorial Swift

Un protocolo define una interfaz de métodos, propiedades y otros requerimientos que se adapten a una tarea o función particular. Un protocolo puede ser adoptado por una clase, estructura o enum para proveer de una implementación a aquellos requerimientos mencionados.

Resumen: lo que definimos en un protocol debe implementarse en los tipos que lo conforman.

Sintaxis de un Protocolo en Swift

Podemos definir protocolos igual que las clases, structs y enums:

protocol MyProtocol {
    // protocol definition goes here
}

Para conformar un protocolo lo ponemos al lado del nombre del tipo separado por dos puntos. Podemos poner tantos protocolos como queramos, eso sí, los debemos separar por comas.

protocol AnotherProtocol {
    // protocol definition goes here
}

struct SomeStructure: MyProtocol, AnotherProtocol {
    // structure definition goes here
}

Si lo hacemos con la clase, y tiene una superclase, debemos poner la superclase antes de los protocolos.

class SomeClass: UIView, MyProtocol, AnotherProtocol {
    // class definition goes here
}

Requerimientos: Propiedad

Un protocolo puede requerir que cualquier tipo que lo conforme proporcione una propiedad de instancia o propiedad de tipo. El protocolo no especifica si debe ser una stored property o una computed property. Solo especifica el nombre de la propiedad requerida y el tipo. El protocolo también especifica si una propiedad debe ser gettable o gettable y settable:

protocol SomeProtocol {
    var mustBeSettabgle: Int { get set }
    var doesNotNeedToBeSettable: Int { get }
}

Ponemos { get set } para indicar que la variable es gettable y settable. Las propiedades de un protocolo siempre son con las keyword var.

Podemos hacer lo mismo para propiedades de tipo:

protocol SomeOtherProtocol {
    static var someTypeProperty: Int { get set }
}

Vamos a ver más ejemplos:

protocol Shippeable {
    var street: String { get }
    var city: String { get }
    var zip: String { get }
}

Hemos creado un protocolo llamado Shippeable con varias propiedades como requerimiento. El tipo que conforme este protocolo deberá especificar street, city y zip. Vamos a ver un ejemplo que conforme el protocolo que acabamos de crear:

struct Product: Shippeable {
    var id: String
    var name: String
    var street: String
    var city: String
    var zip: String
}

let product = Product(id: "1",
                      name: "Mobile",
                      street: "Paseo Centro",
                      city: "SwiftBetaLandia",
                      zip: "0000")

Todas las instancias que hagamos de Product tienen unas stored property llamadas: street, city y zip de tipo String. Esto coincide con los requerimientos de nuestro protocolo Shippeable.

Si no conformamos los requerimientos de un protocolol, Swift nos avisará en tiempos de compilación.

Requerimientos: Métodos

Los protocolos también pueden tener requerimientos de métodos de instancia y métodos de tipo. Estos requerimientos se escriben como las variables que hemos visto en la sección anterior pero sin el body de la función.

protocol Calculable {
    func calculate() -> String
}

struct Calculator: Calculable {
    func calculate() -> String {
        return "Some value..."
    }
}

Un detalle curioso, cuando creamos un protocolo no podemos poner valores por defecto en los parámetros de un método.

Requerimientos: Inicializadores

Los protocolos también pueden tener requerimientos de inicializadores. Creamos estos inicializadores igual que los métodos de la sección anterior.

protocol Initializable {
    init(parameterOne: String, parameterTwo: Int)
}

struct User: Initializable {
    init(parameterOne: String, parameterTwo: Int) {
        // Create initializer
    }
}

Extensiones

Hasta ahora hemos visto que es obligatorio crear lo métodos de un protocolo para conformar de él, pero podemos crear extensiones con un comportamiento por defecto.

Al hacer esto solo tendríamos que conformar el protocolo y tendríamos automáticamente la implementación en nuestro tipo. Vamos a ver un ejemplo enm el que creamos un protocolo con un método que se puede usar en cualquier UIView:

import UIKit

protocol Animatable where Self: UIView {
    func animate()
}

extension Animatable where Self: UIView {
    func animate() {
        print("Do some animation")
    }
}

class MyCustomView: UIView, Animatable { }
let myView = MyCustomView()
myView.animate()

Al conformar Animatable automáticamente obtenemos la implementación por defecto que hemos creado en la extensión. Por eso no necesitamos crearla en nuestro nuevo tipo MyCustomViw.

Delegación

La delegación es un patrón de diseño en el que una clase o struct delega un trabajo a otra. Los pasos serían así:

• La clase A delega su trabajo a la clase B.
• La clase B acaba y notifica a la clase A.
• La clase A continua haciendo su trabajo.

Este patrón es muy usado en la arquitectura MVP (Model-View-Presenter):

• La vista recibe una acción. Un botón ha sido pulsado
• La vista delega la acción al presenter.
• El presenter realiza algún trabajo. Por ejemplo, una llamada a backend.
• El presenter una vez obtiene el resultado llama al que le ha delegado (a la vista) para refrescar la información de pantalla con los nuevos datos.

Lo protocolos son algo básico cuando empiezas a programar en Swift. Al principio pueden ser confusos, pero a medida que los usas ves todo el potencial que hay detrás.