Categories
Swift Development

100 Días de Swift Día 23

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

Entrada anterior

Puntos claves

Accesar archivos en el Bundle de la app

let items = try! fm.contentsOfDirectory(atPath: path)

fm se refiere a FileManager y path se refiere a la ruta desde el Bundle de la App el cual indicamos con una String

try! es necesario por si no se encuentran nuestros archivos

Crear celdas en una tabla

override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
    return pictures.count
}

En este código especificamos el numero de celdas para nuestra tabla, nuestra tabla fue hecha con un ViewController pero luego cambiamos por un UITableViewController que hereda de viewController pero ademas tiene lo necesario para una tabla.

Enlace para abrir la vista a detalle

let cell = tableView.dequeueReusableCell(withIdentifier: "Picture", for: indexPath)

if let vc = storyboard?.instantiateViewController(withIdentifier: "Detail") as? DetailViewController {
}

Estas dos lineas de código se hace referencia a el storyboard con código usando un String como identificador.

Ahora en la segunda linea se usa as? para agregar las propiedades de la clase y por usarlo en nuestro código, si es que el storyboard contiene esa clase

Challenge

Mostrar una tabla con nombres de banderas, vista a detalle y botones para compartir

storyboard

Flags Model

import Foundation

struct ItemCard {
    var id = UUID()
    var name: String
    var description: String
    var capital : String
    var nombreCompleto : String
    
    static var example : [ItemCard] {
        return [...]
    }
}

View Controller

//
//  ViewController.swift
//  ChallengeOne
//
//  Created by Francisco Misael Landero Ychante on 27/08/20.
//  Copyright © 2020 Francisco Misael Landero Ychante. All rights reserved.
//

import UIKit

class ViewController: UITableViewController {

    let estados : [ItemCard] = ItemCard.example
    
    override func viewWillAppear(_ animated: Bool) {
        title = "Estados de 🇲🇽 México" 
      }
      
      //Numero de celdas
      override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
          return estados.count
      }
      
      //crear la celda
      override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
          //crear la celda, usamos el que asignmos en el storyvoard
          //reusamos la celda
          let cell = tableView.dequeueReusableCell(withIdentifier: "estadoCell", for: indexPath)
          
          //le damos un texto a nuestra celda con el nombre de nuestras imagenes
          cell.textLabel?.text = estados[indexPath.row].nombreCompleto
        
          let imageName = UIImage(named: estados[indexPath.row].name)
          cell.imageView?.image = imageName
          return cell
      }
    
    
   override func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
        //buscamos en nuestro story board nuestro detail view
        if let vc = storyboard?.instantiateViewController(withIdentifier: "DetailViewController") as? DetailViewController {
            //en el detailview asignamos el nombre de la imagen segun la celda seleccionada
            
            vc.bind(estados[indexPath.row])
            
            //en el navigation controller empujamos la nueva vista
            navigationController?.pushViewController(vc, animated: true)
        }
        
    }
    
}

DetailViewController

//
//  DetailViewController.swift
//  ChallengeOne
//
//  Created by Francisco Misael Landero Ychante on 27/08/20.
//  Copyright © 2020 Francisco Misael Landero Ychante. All rights reserved.
//

import UIKit

class DetailViewController : UIViewController {
    
    @IBOutlet var image: UIImageView!
    @IBOutlet var name: UILabel!
    @IBOutlet var labelDes: UILabel!
    
    var estado : ItemCard?
      
      
      override func viewDidLoad() {
        
        title = estado?.name
        self.navigationController?.navigationBar.prefersLargeTitles = false
        
        let imageFlag = UIImage(named: estado!.name)
        image.image = imageFlag
        
        name.text = estado?.nombreCompleto
        labelDes.text = estado?.description
        
        //Button en el la barra de navegacion
               navigationItem.rightBarButtonItem = UIBarButtonItem(barButtonSystemItem: .action, target: self, action: #selector(shareTapped))
        
        
      }
      
    func bind(_ model : ItemCard) {
        
        self.estado = model
        
    }
    
    @objc func shareTapped(){
           
           //Verificar si tenemos una imagen
           guard let image = image.image?.jpegData(compressionQuality: 0.8) else {
               print("No se encontro niguna imagen")
               return
           }
           
           guard let imageTitle = estado?.nombreCompleto else {
                      print("No se encontro niguna imagen")
                      return
                  }
            
           
           //Que vamos a compatir
           let vc = UIActivityViewController(activityItems: [image,imageTitle], applicationActivities: [])
           
           //permitir que la ventana semuestra en el ipad
           vc.popoverPresentationController?.barButtonItem = navigationItem.rightBarButtonItem
           
           //mostrar la ventana de compartir
           present(vc,animated: true)
       }
       
    
}

Categories
Swift Development

100 Días de Swift Día 22

Estas son mis notas para el curso

https://www.hackingwithswift.com/100

Día anterior

Crear un botón en la barra de navegación.

 //Button en el la barra de navegacion
        navigationItem.rightBarButtonItem = UIBarButtonItem(barButtonSystemItem: .action, target: self, action: #selector(shareTapped))

Guardar imagen en el carrete

    @objc func shareTapped(){
        
        //Verificar si tenemos una imagen
        guard let image = imageView.image?.jpegData(compressionQuality: 0.8) else {
            print("No se encontro niguna imagen")
            return
        }
        
        //Que vamos a compatir
        let vc = UIActivityViewController(activityItems: [image], applicationActivities: [])
        
        //permitir que la ventana semuestra en el ipad
        vc.popoverPresentationController?.barButtonItem = navigationItem.rightBarButtonItem
        
        //mostrar la ventana de compartir
        present(vc,animated: true)
    }

Nota importante: No olvidar agregar el permiso en el info.plist

Resumen

En este proyecto aprendí lo fácil que es Mostar el menu de compartir en iOS.

También a agregar botones en la barra de navegación

Bibliografía

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

Categories
Swift Development

100 Días de Swift Día 19 a 21

Día 19 a 21

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

“The world is a book, and those who do not travel read only a page.”

Saint Augustine

«El mundo es un libro, y aquellos que no viajan solo han leído una pagina»

Saint Augustine

Guess the Flag

Project 2, part one

Añadir un Navigation View Controller

En nuestro storyboard tocamos nuestro view controller y luego en Editor menu and choose Embed In > Navigation Controller.

Añadir Botones , desde la librería de objetos

Agregamos 3 botones y luego en el inspector de tamaño (Size Inspector) configuramos el tamaño en 200 x 100

y en la Y podemos ajustar la distancia entre los botones

Ahora para crear nuestras constraints esta ves debemos tocar un botón presionar ctrl y con el puntero seleccionar el area blanca de nuestro view controller

y así podemos seleccionar las constraints que queremos aplicar

Ahora importamos nuestras banderas al folder Assets

Ahora en el inspector de imágenes seleccionamos nuestro botón le quitamos el titulo y le asignamos una imagen.

Ahora repetimos nuestro proceso de constraints pero esta vez del segundo botón al primer y del tercero al segundo.

Ahora para que nuestras reglas se apliquen debemos ir al menu Editor > Resolve Autolayout Iusses > Update Frames

Ahora para conectar nuestros botones a nuestro código, tocamos un botón presionamos ctrl y lo arrastramos sobre nuestro ViewController

Making the basic game work: UIButton and CALayer

Crear un array con las banderas del juego y una variable para jugar el puntaje

class ViewController: UIViewController {
    @IBOutlet var button1: UIButton!
    @IBOutlet var button2: UIButton!
    @IBOutlet var button3: UIButton!
    
    //Aqui iran los nombres de las banderas
    var countries = [String]()
    
    //Aqui el puntaje
    var score = 0
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        //cargar los paises
        countries += ["estonia", "france", "germany", "ireland", "italy", "monaco", "nigeria", "poland", "russia", "spain", "uk", "us"]
    }


}

Ahora mostraremos 3 banderas de forma aleatoria

func askQuestion(){
        countries.shuffle()
        
        button1.setImage(UIImage(named: countries[0]), for: .normal)
        
        button2.setImage(UIImage(named: countries[1]), for: .normal)
        
        button3.setImage(UIImage(named: countries[2]), for: .normal)
    }

Ahora para mejorar la vista de nuestras banderas

        //añadir borde a los botones
        button1.layer.borderWidth = 1
        button2.layer.borderWidth = 1
        button3.layer.borderWidth = 1
        
        //añadir cambiar color de borde a los botones
        button1.layer.borderColor = UIColor.lightGray.cgColor
        button2.layer.borderColor = UIColor.lightGray.cgColor
        button3.layer.borderColor = UIColor.lightGray.cgColor

Ahora hay que crear una variable para establecer la respuesta correcta.

    //La respuesta correcta
    var correctAnswer = 0
...
   //elegir una bandera al azar
        correctAnswer = Int.random(in: 0...2)

y mostrar el nombre de esa bandera en el titulo

//Cambiar el titulo de nuestro barra de navegacion
        title = countries[correctAnswer].uppercased()

From outlets to actions: creating an IBAction

Ahora para poder hacer algo cuando se presiona el botón seleccionamos nuestros botones y lo arrastramos hasta un nuevo espacio en nuestro código, seleccionamos esta vez acción y en tipo UIButton

Para los otros botones solo arrastraremos sobre la misma función para que todos funcionen con la misma función

Ahora debemos ir al inspector de atributos y en la sección View ponerles un tag a cada botón, 0 para el primero , 1 para el segundo, 2 para el tercero.

Ahora tenemos que revisar si nuestra respuesta fue correcta y mostrar una alerta

var title: String
        //Determinar si la respuesta fue correcta
        if sender.tag == correctAnswer {
            title = "Correcto"
            score += 1
        } else {
            title = "Incorrecto"
            score -= 1
        }
        
        //Crear una alerta con el titulo de nuestra variable
        let alert = UIAlertController(title: title, message: "Tu puntaje es \(score)", preferredStyle: .alert)
        
        //añadir un boton a nuestra alerta
        alert.addAction(UIAlertAction(title: "Continuar", style: .default, handler: askQuestion))
        
        //finalmente mostramos la alerta
        present(alert, animated: true)
        
        

Hay que actualizar nuestra función askQuestion para que pueda ser utilizada en una alerta

//
//  ViewController.swift
//  Project2
//
//  Created by Francisco Misael Landero Ychante on 08/08/20.
//

import UIKit

class ViewController: UIViewController {
    @IBOutlet var button1: UIButton!
    @IBOutlet var button2: UIButton!
    @IBOutlet var button3: UIButton!
    
    //Aqui iran los nombres de las banderas
    var countries = [String]()
    
    //Aqui el puntaje
    var score = 0
    
    //La respuesta correcta
    var correctAnswer = 0
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        //cargar los paises
        countries += ["estonia", "france", "germany", "ireland", "italy", "monaco", "nigeria", "poland", "russia", "spain", "uk", "us"]
        
        //añadir borde a los botones
        button1.layer.borderWidth = 1
        button2.layer.borderWidth = 1
        button3.layer.borderWidth = 1
        
        //añadir cambiar color de borde a los botones
        button1.layer.borderColor = UIColor.lightGray.cgColor
        button2.layer.borderColor = UIColor.lightGray.cgColor
        button3.layer.borderColor = UIColor.lightGray.cgColor
        
        askQuestion(action: nil)
    }
    
    func askQuestion(action: UIAlertAction!){
        //mezclar las banderas
        countries.shuffle()
        
        //elejir una bandera al azar
        correctAnswer = Int.random(in: 0...2)
        
        
        
        button1.setImage(UIImage(named: countries[0]), for: .normal)
        
        button2.setImage(UIImage(named: countries[1]), for: .normal)
        
        button3.setImage(UIImage(named: countries[2]), for: .normal)
        
        
        //Cambiar el titulo de nuestro barra de navegacion
        title = countries[correctAnswer].uppercased()
    }
    
    @IBAction func buttonTap(_ sender: UIButton) {
        
        var title: String
        //Determinar si la respuesta fue correcta
        if sender.tag == correctAnswer {
            title = "Correcto"
            score += 1
        } else {
            title = "Incorrecto"
            score -= 1
        }
        
        //Crear una alerta con el titulo de nuestra variable
        let alert = UIAlertController(title: title, message: "Tu puntaje es \(score)", preferredStyle: .alert)
        
        //añadir un boton a nuestra alerta
        alert.addAction(UIAlertAction(title: "Continuar", style: .default, handler: askQuestion))
        
        //finalmente mostramos la alerta
        present(alert, animated: true)
        
        
    }
    
    
    

}

Así queda nuestra primera version

Referencias

https://www.hackingwithswift.com/100

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

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

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

Próximos Días

Categories
Swift Development

100 Días de Swift Día 16 a 18

“Of all our inventions for mass communication, pictures still speak the most universally understood language.”

Walt Disney

«De todas nuestros inventos de comunicación masiva, las imágenes siguen siendo el lenguaje universal mas entendido»

Walt Disney

Storm View Project 1, part one

Listado archivos del main Bundle

Obtener archivos del main bundle (contenedor principal de nuestra aplicación )

let fm = FileManager.default
        let path = Bundle.main.resourcePath!
        let items = try! fm.contentsOfDirectory(atPath: path)
        
        for item in items {
            if item.hasPrefix("nssl"){
                // esta es una imagen
                pictures.append(item)
            }
        }
        print(pictures)

Creando una interfaz

Crear una tabla usando UITableViewController

Así que primero debemos modificar nuestro ViewController cambiando la clase

class ViewController: UITableViewController {

Después añadir un TableViewController en nuestro story board

Ahora debemos indicarle a Xcode que este TableViewController y el de nuestro ViewController son el mismo.

Así que en el inspector de identidad seleccionamos nuestro ViewController como la clase

Ahora debemos decirle a Xcode que muestre nuestro TableViewController al iniciar la app para eso ahora elegimos el inspector de atributos y en la sección View Controller seleccionamos is inital View Controler

Ahora en el Document Outline buscamos nuestra celda dentro de la tabla del TableViewController y en el inspector de atributos le cambiamos el nombre del Identifier por Picture y el estilo Basic

Ahora lo que hacemos es ir al menu de Editor y seleccionamos Embed in -> Navigation controller

Ahora en nuestro ViewController crearemos un método que le diga Swift cuantas celdas tiene nuestra tabla

override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return pictures.count
    }

Ahora creamos nuestras celdas

 override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        //crear la celda, usamos el que asignmos en el storyvoard
        //reusamos la celda
        let cell = tableView.dequeueReusableCell(withIdentifier: "Picture", for: indexPath)
        
        //le damos un texto a nuestra celda con el nombre de nuestras imagenes
        cell.textLabel?.text = pictures[indexPath.row]
        return cell
    }

Project 1, part two

Añadiendo una vista de detalles para nuestras imágenes

Para crear la vista a detalle creamos un nuevo archivo de tipo Cocoa Touch Class ademas del nombre hay que suministrar que subclase es, UIViewController en este caso

Ahora añadimos desde la biblioteca un nuevo View Controller lo ponemos a la derecha de nuestra tabla

Ahora hay que añadirle su identificacion en el inspector donde dice Storyboard ID

y en la clase como DetailViewController

Así es como nuestra interfaz de usuario queda conectada con nuestro código

Ahora añadimos UIImageView desde la biblioteca y la arrastramos a nuestro View Controller y la extendemos para que llene la pantalla

Ahora debemos añadir las constraints para que la imagen se vea bien en todos los dispositivos.

hay varias formas de hacerlo, una es en menu editor >  Resolve Auto Layout Issues > Reset To Suggested Constraints.

Ahora para conectar nuestra UIImageView a nuestro código en DetailViewController seleccionamos la UIImageView en el Storyboard y presionamos ctrl en el teclado.

Una line azul aparecerá así que ahora arrastramos hasta la linea donde queremos conectar nuestra imagen y nos aparecerá un globo

Ahora seleccionamos Strong y el nombre imageView

Creemos ahora una propiedad en DetailViewController para guardar el nombre de la imagen

var selectedImage : String?

Para que la vista de la imagen cambie al la imagen que la vamos a pasar usamos este código

if let imageToLoad = selectedImage {
            //cargar la imagen en el storyboard
            imageView.image = UIImage(named: imageToLoad)
        }

Ahora de vuelta en nuestro View Controller crearemos una función para cuando alguien toque una celda de la tabla

 //acciones al seleccionar la celda

    override func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
        //buscamos en nuestro story board nuestro detail view
        if let vc = storyboard?.instantiateViewController(withIdentifier: "Detail") as? DetailViewController {
            //en el detailview asignamos el nombre de la imagen segun la celda seleccionada
            vc.selectedImage = pictures[indexPath.row]
            //en el navigation controller empujamos la nueva vista 
            navigationController?.pushViewController(vc, animated: true)
        }
        
    }

Básicamente lo que este código hace es obtener el index de la celda, buscar el nombre de la imagen en el array y pasarlo a DetailView, luego muestra la vista de DetailView y mostrarla

Afinando los detalles finales

Ocultar la barra de navegación

Primero para hacer que nuestra imagen rellene la pantalla podemos cambiar como se muestra, para vamos al storyboard seleccionamos la Image View y en inspector de atributos seleccionamos en la sección View cómo queremos que nuestra imagen rellena la vista.

Ahora regresando a DetailViewController también podemos añadir la opción de que la barra de navegación se oculte al tocar la imagen para que veamos mejor nuestra imagen.

 
    // ocultar barra de navegacion en toque
    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)
        navigationController?.hidesBarsOnTap = true
    }
    
    // mostrar barra de navegacion en toque
    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillAppear(animated)
        navigationController?.hidesBarsOnTap = false
    }

Ahora para Mostar la flechita en nuestras celdas en el storyboard buscamos nuestro ViewController > TableViewController > Picture y en el inspector de atributos le añadimos un accesorio a la celda

Añadir un titulo

Añadir un titulo es tan fácilmente es como añadirlo bajo super.viewDidLoad()

 title = selectedImage

Ahora si queremos usar títulos grandes en nuestras apps debemos definirlo bajo el titulo en ViewController

 title = "Tormentas ⛈"
        navigationController?.navigationBar.prefersLargeTitles = true

Ahora como no queremos este estilo en nuestro DetailViewController también hay que especificarlo para evitar la herencia

title = selectedImage
navigationItem.largeTitleDisplayMode = .never

y bueno ahí esta no es gran cosa pero es trabajo Honesto

Referencias

https://www.hackingwithswift.com/100

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

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

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

Próximos Días

Categories
Swift Development

100 Días de Swift Día 12

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

Entrada anterior

“I call it my billion-dollar mistake ”

Tony Hoare (talking about the invention of optionals)

«Lo llamo mi error de un millón de dólares»

Tony Hoare (hablando de la invención de los opcionales )

Optionals

Null references cuando una variable no contiene nigua valor, pueden causar varios dolores de cabeza, Swift vida con ellas usando optionals.

Comencemos con un dato sencillo como la edad de una persona, un valor que podemos no conocer, así que podemos crear una variable de tipo Int vacía que contenga ninguna valor y al cual podemos asignarle uno después.

var edad: Int? = nil

Esta variable no guarda ningún valor pero podemos asignarle uno después

edad = 24

Unwrapping optionals

Ahora imaginemos que tenemos un variable de tipo String, una String norma tienen una propiedad count pero un variable vacía no.

var nombre: String? = nil

Por tanto Swift no nos permite usar esta propiedad en este tipo de variables o por lo menos no sin antes hacerles un unwrapping

 if let unwrapped = nombre {
     print("tiene \(unwrapped.count)  letras")
 } else {
     print("No hay un nombre.")
 }

Lo norma es usar la sintaxis if let que hace el unwrapping usando una condición.

Si nombre contienen un string ejecuta el código entre corchetes si no la condición falla y ejecuta el otro código.

Unwrapping with guard

De forma alternativa al unwrapping con if let podemos usar guard let, que espera que al encontrar un nil seas tu quién termine la función, loop o condición.

La mayor diferencia con if let es que tu valor unwrapped permanece usable después del código guard

A continuación un ejemplo

 var nombre: String? = nil

 func saludo(_ nombre: String?) {
     guard let unwrapped = nombre else {
         print("¡No suministraste un nombre!")
         return
     }

     print("Hola, ¡\(unwrapped)!")
 }

 saludo(nombre)

usar guard let nos permite lidiar con los problemas al inicio de nuestro código y lo que queda es código feliz.

Force unwrapping

En ocaciones estamos seguros que un valor opcional no es nil, por ejemplo si queremos convertir un String a Int

let str = "5"
let num = Int(str)

Esto convierte num a un Int opcional pues swift no sabe que el valor que tratas dé convertir es un “5” o un “cinco” . Pero nosotros sí lo sabemos por lo que es seguro forzar el unwrapping usando !

let num = Int(str)!

Como resultado swift convertirá tu opcional en un Int regular pero cuidada si tu valor contienen un nil tu código fallara y tu app se detendrá. Así que ten cuidado de solo forzar el unwrapping cuando estes seguro de que el valor no sera nil.

Implicitly unwrapped optionals

Los opcionales implícitos son similares a los opcionales normales, pero ya están unwrapped, los Implicitly unwrapped optionals son creados al añadir un signo de admiración después del tipo de valor.

let edad: Int! = nil

Este tipo de opcionales también harán fallar tu condigo si contienen un nil así que solo deben ser usados cuando necesitas una variable y luego estas seguro que le asignaras un valor antes de usarla.

Nil coalescing

El operador Nil coalescing permite hacer el unwrapping y si el valor es nil puedes proporcionar un valor por default el operador se represan con dos signos de interrogación ?? después de nuestra variable opcional y después debemos proporcionar un valor.

//Esta función regresa un String opcional 
func nombreDeUsuario(for id: Int) -> String? {
     if id == 1 {
         return "Taylor Swift"
     } else {
         return nil
     }
 }
  
//Aqui usamos el nil coalescing operador 
let usuario = nombreDeUsuario(for: 15) ?? "Anonymoux"

En el ejemplo de arriba, se usa el nil coalescing operator si el valor que nos regresa la función no es nil ese es el que se usa, pero si es nil se usa lo que esta después de operador

Optional chaining

Swift nos proveer un atajo cuando usamos opcionales, si quieres acceder a algo como a.b.c y b es opcional, puedes usar un ? para activar el optional chaining.

Cuando el código corre swift checara si b tiene un valor, y si es nil el resto de la línea sera ignorado y swift regresara nil, pero si tienen un valor sera unwrapped y seguirá ejecutando el código.

let nombres = ["John", "Paul", "George", "Ringo"]

let beatle = nombres.first?.uppercased()

Optional try

En dias pasados vimos como manejar errores en una función, cuando se suministra un dato erróneo

Writing throwing functions
enum errorDeContraseña: Error {
    case muyObvia
}

func revisarContraseña(_ contraseña: String) throws -> Bool {
    if contraseña == "contraseña" {
        throw errorDeContraseña.muyObvia
    }

    return true
}

do {
     try revisarContraseña("contraseña")
     print("¡Buena contraseña!")
 } catch {
     print("¿En serio 😐?")
 }

Para correr una throwing function usamos do, try y catch

Hay dos alternativas para try la primera es try? que cambia la throwing function por una función que regresa un nil como resultado


if let resultado = try? revisarContraseña("contraseña") {
    print("El resultado fue  \(resultado)")
} else {
   print("¿En serio 😐?")
}

La otra alternativa es try! que solo debes usar en caso que estes seguro que la función no fallara, pues si lo hace tu código fallara y se detendrá (crash)

try! revisarContraseña("Secreto")
print("ok")

Failable initializers

Cuando vimos force unwrapping convertimos un string a un integer opcional

let str = "5"
let num = Int(str)

Esto es se conoce como un failable initializer un initializer que podría o no funcionar.

Puedes escribir los propios usando init?() en lugar de init y responder nil si las cosas no van bien.

como en el siguiente ejemplo

struct Persona {
    var id: String

    init?(id: String) {
        if id.count == 9 {
            self.id = id
        } else {
            return nil
        }
    }
}

Typecasting

Swift siempre debe saber el tipo de valores de tus variables, pero a veces tenemos mas información que swift, tomemos el siguiente ejemplo.

class Animal { }
class Pez: Animal { }

class Perro: Animal {
    func hacerRuido() {
        print("¡Guau!")
    }
}
let mascotas = [Pez(), Perro(), Pez(), Perro()]

Swift puede ver que tanto Perro como Pez heredan de Animal así que infiere que el array es de Animal

Si queremos un loop sobre mascotas y le pida a los perros que hagan ruido, swift puede revisar que cada elemento de mascotas sea o no perro y entonces llamar a hacerRuido

Paro eso usamos as? lo cual responde con un opcional, nil si no es de la clase esperada.

for mascota in mascotas {
    if let perro = mascota as? Perro {
        perro.hacerRuido()
    }
}

Resumen

Los opciones nos dejan presentar la ausencia de un n valor de una forma limpia y no ambigua

Swift no nos deja usar opcionales sin hacerles primero un unwrapping, usando if let o guard let.

Puedes forzar un unwrapping con !, pero recuerda que si tu valor es nil tu código fallara y se detendrá.

Implicitly unwrapped optionals no requieren que hagas un unwrapping pero si no te aseguras de asignarles un valor tu código fallara y se detendrá.

Puedes usar nil coalescing (??) para hacer unwrap y proveer un valor por default.

Optional chaining es usado para manipular un opcional, si el opcional resulta ser nil la linea de código es solo ignorado.

Puedes usar try? para convertir una throwing function en un valor opcional, o usar try! para detener tu código si hay un error.

Puedes usar init?() para regresar nil si recibes un dato incorrecto.

Puedes usar typecasting (as?) para convertir un tipo de valor en otro.

Referencias

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

https://www.hackingwithswift.com/100

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

Categories
Articulo personal Swift Development

100 Días de Swift Día 10

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

Entrada anterior

“Any fool can write code that a computer can understand, but good programmers write code that humans can understand.”

Martin Fowler

«Cualquier tonto puede escribir código que una computadora pueda entender, pero buenos programadores pueden escribir código qué humanos pueden entender.»

Martin Fowler

Classes

Las clases son similares a las structs, te permiten nuevos tipos de datos, con propiedades y métodos.

Las clases tienen por lo menos cinco diferencias principales con las Clases

Creating your own classes

La primera es que las clases no vienen un un inicializador por default, siempre debes crearlo tú.

class Perro {
    var nombre: String
    var raza: String

    init(nombre: String, raza: String) {
        self.nombre = nombre
        self.raza = raza
    }
}

Crear instancias de una clase es igual que crear instancias de una estructura.

let cachorrito = perro(nombre: "Toby", raza: "Poodle")

Class inheritance

La segunda diferencia es que puedes crear una clase partir de otra clase ya existente, esto hereda todas las propiedades y métodos de la clase padre.

Por ejemplo creemos una clase en base a nuestra clase anterior Perro

class Sabueso: Perro {

}

Esta clase nueva hereda el inicializador y los parámetros de su clase padre

Aun así podemos crear un inicializador propio de Sabueso por ejemplo ya que sabemos que nuestro perro es un sabueso podemos iniciar nuestra clase sabueso solo con el nombre.

class Sabueso: Perro {
    
    init(nombre: String) {
        super.init(nombre: nombre, raza: "Sabueso")
    } 
}

Por razones de seguridad, swift siempre te pedirá llamar al «super.init» al crear una clase hija

let cazador = Sabueso(nombre: "Maylo")

Overriding methods

Las clases hijas pueden remplazar los métodos de sus padres con implementaciones propias.

Este proceso se conoce como «overriding»

Añadamos un método a nuestra clase Perro

class Perro {
    var nombre: String
    var raza: String

    init(nombre: String, raza: String) {
        self.nombre = nombre
        self.raza = raza
    }

 
}

Ahora podemos llamar este método desde cualquier instancia de su clase hija

cazador.ladrar()

Ahora podemos remplazar el método en nuestra clase hija para ponerle nuestra propia implementación.

Para eso usamos la palabra reservada «override» esto sire para evitar remplazar métodos por accidente.

 class Sabueso: Perro {
     
     init(nombre: String) {
         super.init(nombre: nombre, raza: "Sabueso")
     }

    override func ladrar() {
        print("¡Woolf! ¡Woolf! ¡Woolf!")
    }
 }
 
 let cazador = Sabueso(nombre: "Maylo")
cazador.ladrar()
// esto imprime "¡Woolf! ¡Woolf! ¡Woolf!"

Final classes

Sin bien la herencia es algo genial, no es algo que siempre queramos, por ejemplo si queremos marcar nuestras clases como finales y evitar que otros desarrolladores remplacen nuestros métodos solo debemos marcar la clase como final.

 final class Perro {
     var nombre: String
     var raza: String

     init(nombre: String, raza: String) {
         self.nombre = nombre
         self.raza = raza
     }
     
     func ladrar (){
         print("¡Guau! ¡Guau! ¡Guau!")
     }
 }
Cómo vemos eso impide la herencia.

Copying objects

La tercera diferencia entre clases y estructuras es lo que ocurre al copiarla

Al copiar una estructura, tanto la original como la copia son instancias diferentes, cambiar una no afecta la otra.

Cuando copias una clase, tanto la original como la copia son la misma, cambiar algo en una afecta a la otra.

let cachorrito = Perro(nombre: "Toby", raza: "Poodle")

let copiaDeCachorrito = cachorrito

copiaDeCachorrito.nombre = "Firulais"

print(cachorrito.nombre)

Al correr este código veras que al editar la copia de cachorrito también afecta al original. Esto ocurre por que ambas instancias apuntan al mismo espacio en al memoria

Deinitializers

La curta diferencia entre clases y estructuras es que las clases pueden tener «Deinitializers» código que se ejecuta cuando una instancia de la clase es destruida.

Para crear un Deinitializer usamos la palabra reservada «deinit»

class Chihuahua: Perro {
    init() {
        
        super.init(nombre: "Panchito", raza: "Chihuahua")
        print("¡Ahy ahy \(nombre) esta vivo!")
    }
    
    deinit {
        print("¡Ahy ahy 🤧😭 \(nombre) ya se murio!")
    }
}
 
for _ in 1...3 {
    let perro = Chihuahua()
}
Eso fue divertido

Mutability

La quinta y ultima diferencia entre clases y estructuras es la manera en como lidian con las constantes

En una estructura si tenemos una instancia que es una constante, y dentro de ella variables, la variable no puede ser cambiada pues toda la estructura es una constante.

Sin embargo en una clase si tenemos una instancia que es una constante y dentro tenemos una variable esta si que puede ser cambiada, por eso clases no necesitan mutating en sus métodos que cambian propiedades.

let perrito = Perro(nombre: "Toby", raza: "Callejero")
perrito.nombre = "Clifor"

print(perrito.nombre)

Si queremos evitar que esto pase debemos definir nuestra parámetro como una constante.

class Perro {
    //ahora ya no podrá ser cambiado
     let nombre: String
     var raza: String

     init(nombre: String, raza: String) {
         self.nombre = nombre
         self.raza = raza
     }
     
     func ladrar (){
         print("¡Guau! ¡Guau! ¡Guau!")
     }
  
 }

Resumen

Las clases y las estructuras son similares, ambas pueden crear tipos de datos personalizados, con sus propias propiedades y métodos

Las clases pueden heredar propiedades y métodos a otras, mediante un sistema de jerarquía llamado herencia en el cual creas clases a partir de otras

Puedes evitar la herencia marcando tu clase como final

El remplazo de métodos en una clase hija permite crear un remplazo del método de la clase padre con su propia implementación esto en POO se conoce como polimorfismo.

Cuando dos variables (o instancias) apuntan a la misma clase ambos comparten el mismo espacio de memoria, modificar una modifica a la otra.

Las clases tienen desinicializadores que es código que corre cuando una instancia de la clase es destruida.

Las clases aunque sean constantes pueden ser modificadas si alguna de sus propiedades es una variable.

//y bueno esas fueron mis notas para clases sin duda un tema super interesante y muy relacionado con POO

Referencias

https://www.hackingwithswift.com

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

Proximo día

Categories
Swift Development

100 Días de Swift Día 9

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

Entrada anterior

“I choose a lazy person to do a hard job, Because a lazy person will find an easy way to do it.”

Bill Gates

«Escojo a una persona floja para hacer un trabajo difícil, por que una persona floja buscara la forma mas fácil de hacerlo»

Bill Gates

Structs, part two

Referring to the current instance

Cuando creas un metodo con parámetros que tienen el mismo nombre que los parámetros de tu Struc puedes usar la constante self para distinguir entre uno y otro

struct Usuario {
    var nombre: String
    
    init(nombre: String) {
        self.nombre = nombre
    }
}

var usuario = Usuario(nombre: "Juan")
print(usuario.nombre)

Lazy properties

Como una optimización de recursos, Swift deja crear «Lazy vars» que son variables que no se crean hasta que son llamadas por primera vez, por ejemplo en teoría crear una familia debería tomar algo de tiempo para una persona


struct Familia {
    init() {
        print("Esto deberia tomar un par de años por lo menos ")
    }
}


struct Usuario {
    var nombre: String
    lazy var familia = Familia()
    init(nombre: String) {
        self.nombre = nombre
    }
}


var usuario = Usuario(nombre: "Juan")
print(usuario.nombre)

Si colocamos la palabra lazy antes de nuestra var la variable no se creara hasta que esta sea llamada por primera vez.

Algunos de nuestros usuarios quizás ni la usen.

Como ves nuestra variable no es creada hasta la llamamos por primera vez

Static properties and methods

Todas las propiedades y métodos que creamos pertenecen a las instancias individuales de cada estructura, pero si marcamos una variable como estática, esta pertenecía a la estructura y no a su instancia, esto quiere decir que sera compartida entre todas las instancias que creemos.

struct Estudiantes {
    var nombre : String
    static var tamañoDelaClase = 0
    
    init(nombre: String) {
        self.nombre = nombre
        Estudiantes.tamañoDelaClase +=  1
    }
}


let mario = Estudiantes(nombre: "Mario")
let juan = Estudiantes(nombre: "Juan")
print(Estudiantes.tamañoDelaClase)

Puedes ver que para acceder a esta variable entramos directo en Estudiantes en lugar de usar self o el nombre de la instancia.

Access control

El control de acceso te deja restringir que código pueden usar propiedades y métodos, esto es importante por que nos sirve para evitar que la gente lea propiedades de forma directa.

Algo muy importante al realizar la Abstracción en POO

Para proteger una variable solo tenemos que añadir la palabra clave «private»

Otra palabra clave es «public» que hace sorpresa sorpresa lo opuesto.

Resumen

Puedes crear tus propios tipos de datos usando Structures, las cuales pueden tener sus propias propiedades y métodos

Puedes usar stored properties o usar computed properties para calcular valores al momento

Los Initializers son métodos especiales para crear structs, las structs tienen uno por default, pero podemos crear nuestro propio inicializador personalizado. Solo debemos asegurarnos todos los parámetros tenga un valor antes de que termine.

Usamos la constate self. para referirnos a la instancia actual de nuestra struct dentro de un método.

Usamos Lazy para crear una propiedad hasta que esta es llamada por primera vez

Puedes compartir propiedades y métodos entre instancias a usar la palabra reservada Static

Access control te deja restringir que código puede usar propiedades y métodos.

//y esas fueron las structs, un concepto muy importe en Swift 

Referencias

https://www.hackingwithswift.com

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

Proximo Día

Categories
Swift Development

100 Dias de Swift Día 8

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

Entrada anterior

“The programmer at wit’s end… can often do best by disentangling themself from their code, rearing back, and contemplating their data. Representation is the essence of programming.”

Fred Brooks

«El programador al final, hace mejor al distanciarse del código, leerlo otra vez, y contemplar su contenido. Representar es la esencia de programar.»

Fred Brooks

Structs part one

Creating your own structs

Las estructuras o «Structs» nos permiten crear nuestros propios tipos de datos, las structs pueden tener sus propias variables y funciones


struct Deporte {
    var nombre: String
}

var juegoConPelota = Deporte(nombre: "Baloncesto")
print(juegoConPelota)

ahora dado que tanto nuestro struct como su propiedad nombre son variables podemos modificarlas como cualquier variable

juegoConPelota.nombre = "Tenis"

print(juegoConPelota.nombre)

Las propiedades de una struct pueden tener valores por default y también funciona con la inferencia de tipo de valor.

Computed properties

Ahora que tenemos nuestra sctruct podemos añadir mas propiedades por ejemplo una propiedad calculada o «Computed propertie» que es básicamente lo que dice su nombre una propiedad que corre un pedazo de código para calcular su valor.

Aquí un ejemplo, añadimos dos propiedades mas a nuestra struct una un booleano y la otra una propiedad calculada.

struct Deporte {
    var nombre: String
    var esOlimpico: Bool
    var estatusOlimpico : String {
        if esOlimpico {
            return "\(nombre) es un deporte olimpico"
        } else {
            return "\(nombre) no es un deporte olimpico"
        }
    }
}

var juegoConPelota = Deporte(nombre: "Damas Chinas", esOlimpico: false)
print(juegoConPelota.estatusOlimpico )

Como vez las propiedades calculadas nos dan infinitas posibilidades.

Property observers

Podemos añadir observadores a nuestras variables para correr código antes o después de que cambien sus propiedades


struct Tarea {
    var nombre: String
    var avance: Int {
        didSet {
            print("\(nombre) esta ahora \(avance)% completada")
        }
    }
}

var lavarRopa = Tarea(nombre: "Lavar la ropa", avance: 10)

lavarRopa.avance = 30
lavarRopa.avance = 60
lavarRopa.avance = 100

También existe «willSet» que ejecuta código cuando el valor cambia, pero casi nadie lo usa.

Methods

Las structs pueden tener métodos dentro de ellas, y esas funciones pueden usar las propiedades de la struct si lo necesitan.

Las funciones dentro de una struct se llaman métodos o «Methods» pero aun usan la palabra reservada func

struct Ciudad {
    var poblacion: Int

    func recolectarImpuestos() -> Int {
        return poblacion * 1000
    }
}

let CDMX = Ciudad(poblacion: 1_000_000)
CDMX.recolectarImpuestos() 

Como el métodos pertenece a la estructura tenemos que llamarlo a partir de ella.

Mutating methods

Si una estructura tiene una variable, pero la instancia de la estructura fue creada como una constante esa propiedad no se puede cambiar, sin importar si tu propiedad es una variable.

El problema es que al crear una struct, swift no sabe si sera una variable o una constante, por eso swift no te deja crear métodos que modifiquen propiedades a menos que lo especifiques

Si quieres cambiar una propiedad debes usar «mutating» antes de func

struct Ciudad {
    var poblacion: Int

    func recolectarImpuestos() -> Int {
        return poblacion * 1000
    }
    
    mutating func cambiarPoblacion (nuevaPoblacion: Int) {
        poblacion = nuevaPoblacion
    }
}

var CDMX = Ciudad(poblacion: 1_000_000)
CDMX.cambiarPoblacion(nuevaPoblacion: 2_000_000)
print(CDMX.poblacion)

Swift solo dejara usar este método en instancias que sean variables.

Properties and methods of strings

Resulta que todo este tiempo que hemos estado usando Strings están son structs 🤯

Comencemos creando una nueva string

let yodaDice = "Do or do not, there is no try."

ahora podemos acceder a una de sus propiedad como count para saber cuantos caracteres tiene nuestra string

print(yodaDice.count)

Strings también tienen un método llamada «hasPrefix» que


print(yodaDice.hasPrefix("Do"))

Que regresa falso o verdadero si nuestra string inicia con esos caracteres.

Podemos también poner nuestra string en mayúsculas usando el método «uppercased()»

print(yodaDice.uppercased())

Hay muchos métodos mas que string tiene y que podemos descubrir con la auto compleción deXcode al escribir «.»

Properties and methods of arrays

Resulta que los arrays son también structs 😲 y tienen sus métodos también.

Aqui un par de ejemplos

//Array de ejemplo
var toys = ["Woody"]

//Contar elementos en el array 
print(toys.count)

//Añadir nuevo elemento a Array
toys.append("Buzz")

//Reordenar elementos del array alfabéticamente 
toys.firstIndex(of: "Buzz")
print(toys.sorted())

Initializers

Los Inicializadores son métodos especiales para te proveen diferentes maneras de crear tus structs, las structs vienen con un «Initializer» por defecto, que te pide que un valor por cada propiedad de tu struct

struct Usuario {
     var nombre: String
 }
var usuario = Usuario(nombre: "Juanito")

Podemos remplaza el incializador por default de la siguiente manera

struct Usuario {
     var nombre: String
    init() {
        nombre = "Anonimo"
        print("Usuario anonimux creado")
    }
 }

var usuario = Usuario()
usuario.nombre = "Juan"

El initializer no requiere que escribas func al principio pero debes asegurarte que todas las propiedades tengan un valor antes de que termine.


//y bueno esa fue la primera parte de Structs mañana seguimos con la segunda parte. 

Proximo día

Referencias

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

https://www.hackingwithswift.com/100

Categories
Swift Development

100 Dias de Swift Día 7

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

Entrada anterior

“Energy and persistence conquer all things”

Benjamin Franklin 

«Energía y tenacidad, conquistan todas las cosas»

Benjamin Franklin

Closures, part two

Esta es la segunda parte del tema de closures y aquí es donde las cosas se vuelven mas complejas.

Using closures as parameters when they accept parameters

Anteriormente usamos «() -> Void» para pasar un closure que no acepta parámetros y nos regresa nada, pero ahora especificaremos un tipo de valor dentro de los paréntesis

func viajar(acción: (String) -> Void) {
     print("Estoy listo para partir.")
     acción("CDMX")
     print("¡Ya llegue!")
 }

viajar { (lugar: String) in
    print("voy para \(lugar) en mi auto")
}

Recuerda los nombres de los parámetros en los closures se indican dentro de las llaves

Using closures as parameters when they return values

De la misma manera podemos remplazar Void por un valor para que nuestra Closure regrese y luego usarlo dentro de la función.

func viajar(acción: (String) -> String) {
     print("Estoy listo para partir.")
     let adondeVas = acción("CDMX")
     print(adondeVas)
     print("¡Ya llegue!")
 }

viajar { (lugar: String) -> String in
    return "voy para \(lugar) en mi auto"
}

Shorthand parameter names

Hemos creado una función que acepta un closure como parámetro que a su vez acepta una String parámetro y regresa una String

Como Swift sabe que nuestro parámetro es una String y que estamos regresando una String podemos simplificar nuestra expresión de esta forma

//Sin especificar el tipo de parametro
viajar { lugar -> String in
    return "voy para \(lugar) en mi auto"
}

//Sin especificar el tipo de valor que retorna
viajar { lugar  in
    return "voy para \(lugar) en mi auto"
}

Closures with multiple parameters

También es posible utilizar Closures con multiples parámetros

func viajar(acción: (String, Int) -> String) {
     print("Estoy listo para partir.")
     let adondeVas = acción("CDMX", 60)
     print(adondeVas)
     print("¡Ya llegue!")
 } 

viajar { (lugar, km)  in
    return "voy para \(lugar) a \(km)km/hora en mi auto"
}

//version simplificada
viajar {
    return "voy para \($0) a \($1)km/hora en mi auto"
}
 

Como puedes ver en el segundo ejemplo es incluso posible simplificar aun mas la expresión usando nombres de parámetros acortados «$0» y «$1» aun así muchas personas evitan usarlos pues pueden dificultar la legibilidad de tu código.

Returning closures from functions

De la misma forma que podemos pasar closures como parámetros en una función, también podemos devolverlas como respuesta de una función.

La sintaxis aquí es un poco confusa por que usamos dos veces «->»

En el siguiente ejemplo creamos la función viajar que no acepta parámetros pero regresa un closure, este closure acepta una string y regresa nada como respuesta.

func viajar() -> (String) -> Void {
    return {
        print("Voy a \($0)")
    }
}
//función sin parámetros devuelve como respuesta un closure que acepta una string y devuelve como respuesta nada 

Ahora podemos llamar a viajar para obtener esa closure y luego usarla

let resultado = viajar()
resultado("Guadalajara")

Ahora técnicamente podemos llamar directamente a la closure pero la verdad no es muy recomendado


let resultado = viajar()("Guadalajara")

Capturing values

Si usas un valor externo dentro de tu closure, swift lo captura, esto quiere decir que lo guarda junto tu closure.

Modifiquemos nuestra closure en viajar para contar cuantas veces es llamada.

func viajar() -> (String) -> Void {
    var contador = 1
    return {
        print("Por \(contador)vez  Voy a \($0)")
        contador += 1
    }
}

Ahora cuando llamemos este closure podremos ver que el valor del contador es conservado

let resultado = viajar()
 
resultado("Guadalajara")
resultado("Guadalajara")
resultado("Guadalajara")
¡Genial! ¿no?

Resumen

Puedes asignar closures a variables y luego llamarlas

Los closures pueden aceptar parámetros y responder con valores, como una función normal

Puedes pasar closures como parámetros en una función, estas closures pueden tener sus propios parámetros y regresar respuestas con sus propios valores

Si el ultimo parámetro de una fungino es una closure, puedes usar una sintaxis reducida

Swift provee de manera automática nombres cortos para los parámetros de tu closure como $0 y $1

Sí usas valores externos en una closure, estos son capturados y guardados. para que puedas hacer referencia a ellos después

//y así terminamos con closures un tema bastante complejo pero que es usado mucho en SwiftUI veremos que tal en UIKIT

Referencias

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

https://www.hackingwithswift.com/100

Proximo día