Categories
Swift Development

100 Días de Swift Día 11

Estas son mis notas para el curso https://www.hackingwithswift.com/100

Entrada anterior

“Inside every large program, there is a small program trying to get out.”

Tony Hoare

«Dentro de todo gran programa, hay un pequeño programa tratado de salir»

Tony Hoare

Protocols

Los protocolos son una forma de describir que propiedades y métodos algo debe tener

Por ejemplo quizás queramos crear una función que acepte algo con un ID y no nos interesa precisamente que tipo de dato se este usando.

Comenzamos creando nuestro propio protocolo, en el definimos que requerirá que los tipos que se adapten al protocolo tengan una variable ID que pueda ser escrita y leída («get» and «set» )

protocol Identificable {
    var id: String { get set }
}

No podemos crear instancias de este protocolo directamente pues su objetivo es describir simplemente los que queremos.

Por ejemplo podemos usarlo en un struct

struct Usuario: Identificable {
    var id: String
}

Esta struct tendrá que tener un id tipo string si quiere conformarse al protocolo que definimos.

De la misma forma podemos crear una función

func mostrarID (loQueSea : Identificable ){
    print("El id es \(loQueSea.id)")
}

Protocol inheritance

Al igual que las clases los protocolos pueden usar herencia, pero con la diferencia de que puedes heredar de multiples protocolos al mismo tiempo y luego poner tu propio protocolo sobre todos ellos.

Comencemos creando tres protocolos nuevos.

protocol SeLePuedePagar {
    func calcularSueldo() -> Int
}

protocol NecesitaCapacitacion {
    func capacitar()
}

protocol TieneVacaciones {
    func tomarVacaciones(dias: Int)
}

Ahora lo mas genial, podemos combinar estos tres protocolos en uno solo

protocol Empleado: SeLePuedePagar, NecesitaCapacitacion, TieneVacaciones {}

Ahora en lugar de hacer que nuestros datos se conformen a cada uno de estos tres protocolos, podemos hacer que se conformen solo al protocolo Empleado

Extensions

Las extensiones hacen precisamente lo que dicen sus nombres, nos permiten añadir funciones o métodos a tipos de datos ya existentes, por ejemplo podemos añadir un método para obtener el cuadrado de un Int

extension Int {
    func alCuadrado() -> Int {
        return self * self
    }
}

var numero =  1
numero.alCuadrado()

Swift no nos permite añadir propiedades almacenadas (stored properties) a una extensión pero si propiedades calculadas (computed properties) por ejemplo

extension Int {
    var esPar: Bool {
        return self % 2 == 0
    }
}

Protocol extensions

Los protocolos nos permiten describir que métodos algo debe tener, pero no provee el código dentro.

Las extensiones nos dejan tener nuestros propio código y métodos pero lo aplican solo a un tipo de datos.

Protocol extensions resuelven ambos problemas, son similares a las extensiones nórmales pero en lugar de aplicarse a un tipo de dato como Int se extienden a todo un protocolo así que todos los datos que se conformen a ese protocolo lo obtienen.

En este ejemplo tenemos un Array y un Set con algunos nombres

let pythons = ["Eric", "Graham", "John", "Michael", "Terry", "Terry"]
let beatles = Set(["John", "Paul", "George", "Ringo"])

Ambos tipos de datos se conforman con el protocolo Collection, así que podemos crear una extensión para ese protocolo.


let pythons = ["Eric", "Graham", "John", "Michael", "Terry", "Terry"]
let beatles = Set(["John", "Paul", "George", "Ringo"])

extension Collection {
    func recapitular() {
        print("Son \(count) de nosotros:")

        for name in self {
            print(name)
        }
    }
}

El nuevo método que hemos creado se añadió a todos los tipos de datos con ese protocolo.

pythons.recapitular()
beatles.recapitular()

Protocol-oriented programming

Protocol extensions nos permite añadir métodos por default a nuestros protocolos, eso hace mucho mas fácil que los tipos de datos se conformen a nuestros protocolos

Por ejemplo si creamos un protocolo llamado Identificable que requiere que se tenga un ID y un método llamado identificarse()

protocol Identificable {
    var id: String { get set }
    func identificarse()
}

En este caos todas los tipos de datos que quieran conformarse al protocolo Identificable necesitan implementar su propio método identificarse()

¿Pero qué tal si nosotros los proporcionamos por default con un Protocol extension?

extension Identificable {
    func identificarse() {
        print("Mi ID es \(id).")
    }
}

Ahora podemos crear una Struct que se conforme a nuestro protocolo, y que ademas de manera gratuita obtenga una implementación de identificarse()

struct Agente: Identificable {
    var id: String
}

let james = Agente(id: "007")
james.identificarse()

Resumen

Los protocolos describen que métodos y propiedades debe tener un tipo de dato que quiere conformarse a ellos. Pero no proveen la implementación de esos métodos.

Puedes construir protocolos sobre otros protocolos, igual que las clases.

Las extensiones nos permiten añadir métodos y propiedades computadas a tipos de datos ya existentes

Las extensiones de protocolos nos permiten añadir métodos y propiedades computadas a protocolos ya existentes.

Protocol-oriented programming consisten en basar la arquitectura de tu app en una serie de protocolos , y luego usar una serie de protocolos para proveer implementaciones de métodos por default.

//y ese fue el resumen de protocolos, sin duda una tema fascinante que te ayudará a reducir la cantidad de código que reescribes, ademas de proveer un nuevo tipo de paradigma de programación. 

Referencias

https://www.hackingwithswift.com/100/11

https://www.hackingwithswift.com/100

https://developer.apple.com/videos/play/wwdc2015/408/

Proximo dia

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *