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

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

Protocolos en Swift. Usamos protocolos para obligar a los tipos que lo conforman a cumplir los requerimientos que queramos, con variables, métodos etc. Los protocolos también los usamos para el patrón de diseño delegación. Lee para aprender más sobre protocolos en Swift.

SwiftBeta
Aprende Swift desde cero

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
}
Protocolo en Swift

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
}
Conformar un Protocolo en una Struct

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
}
Conformar un Protocolo en una Class

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 }
}
Requerimientos de un protocolo: Propiedades de Instancia

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 }
}
Requerimientos de un protocolo: Propiedades de Tipo

Vamos a ver más ejemplos:

protocol Shippeable {
    var street: String { get }
    var city: String { get }
    var zip: String { get }
}
Ejemplo de un Protocolo en Swift

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")
Ejemplo de conformar un Protocolo en Swift

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..."
    }
}
Requerimientos de un protocolo: Métodos
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
    }
}
vRequerimientos de un protocolo: Inicializadores

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()
Protocolos con valores por defecto

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.


Hasta aquí el post de hoy, gracias por leernos! 🤓
👉👉 SUSCRÍBETE al CANAL de youtube
Si tienes preguntas no dudes en contactar con nosotros a través de Twitter

Si quieres seguir aprendiendo sobre SwiftUI, Swift, Xcode, o cualquier tema relacionado con el ecosistema Apple


Swift Introducción