Blog

Modo consola

Introduce una palabra: coche
Traducción: car

Introduce una palabra: car
Traducción: coche

Introduce una palabra: casa
Traducción: house

Introduce una palabra: dog
Traducción: perro

Introduce una palabra: aaaa
Traducción: palabra no encontrada

Introduce una palabra:
...

var palabras = [("coche", "car"), 
                ("gato",  "cat"),
                ("perro", "dog"),
                ("casa", "house")]

func traduce(_ entrada:String) -> String {
    for palabra in palabras {
        if palabra.0 == entrada { return palabra.1 }
        else if palabra.1 == entrada { return palabra.0 }
    }
    return "palabra no encontrada"
}

repeat {
    print("Introduce una palabra: ", terminator:"")
    let entrada = readLine()!
    let salida = traduce(entrada)
    print("Traducción: \(salida)\n")
}
while true

Aplicación iOS

Traducir con el evento de cambio de texto

//
//  ViewController.swift
//  Traductor
//

import UIKit

class ViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
    }

    var palabras = [("coche", "car"),
                    ("gato",  "cat"),
                    ("perro", "dog"),
                    ("casa", "house")]

    @IBOutlet var traduccion: UILabel!
    
    func traduce(_ entrada:String) -> String {
        for palabra in palabras {
            if palabra.0 == entrada { return palabra.1 }
            else if palabra.1 == entrada { return palabra.0 }
        }
        return "palabra no encontrada"
    }
    
    @IBAction func traduce(_ entrada: UITextField) {
        traduccion.text = traduce(entrada.text!)
    }
}

Traducir al pulsar un botón

//
//  ViewController.swift
//  Traductor
//

import UIKit

class ViewController: UIViewController {

    @IBOutlet var entrada: UITextField!
    @IBOutlet var salida: UILabel!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view.
    }

    var palabras = [("coche", "car"),
                    ("gato",  "cat"),
                    ("perro", "dog"),
                    ("casa", "house")]
    
    func traduce(_ entrada:String) -> String {
        for palabra in palabras {
            if palabra.0 == entrada { return palabra.1 }
            else if palabra.1 == entrada { return palabra.0 }
        }
        return "palabra no encontrada"
    }

    @IBAction func boton(_ sender: UIButton) {
        salida.text = traduce(entrada.text!)
    }
}

Utilizando una clase y una estructura para añadir nuevas palabras y guardar el diccionario

Instalación de La librería «Disk»

Vamos a proceder a instalar la librería «Disk» utilizando el gestor de librerías «CocoaPods«:

• Crear un proyecto de Xcode del tipo «TabbedApp»
• Abre un terminal y ves al directorio del proyecto utilizando el comando $ cd .
• Crear el fichero Podfile utilizando el comando $ pod init.
• Abre el fichero «Podfile». La primera línea debe indicar la plataforma y la versión de iOS:  platform :ios, '12.2'.
• Añade la línea pod 'Disk' dentro de la sección target.
• Guarda el fichero.
• Instala la librería con la instrucción $ pod install .
• Abre el fichero .xcworkspace que se ha creado. A partir de ahora deberemos abrir ese fichero en vez del .xcodeproj .

El contenido final del archivo «Podfile» sería el siguiente:

platform :ios, '12.2'

target 'traductor' do
  use_frameworks!

  # Pods for Traductor
  pod 'Disk'
end

Diccionario.swift

//
//  Diccionario.swift
//  Traductor
//

import Disk

struct Palabra : Codable {
    let es : String
    let en : String
}

class Diccionario {
    var palabras : [Palabra] = []
    
    func add(_ palabra:Palabra) {
        self.palabras += [palabra]
    }
    
    func traduce(_ entrada:String) -> String {
        for palabra in self.palabras {
            if palabra.es == entrada { return palabra.en }
            else if palabra.en == entrada { return palabra.es }
        }
        return "palabra no encontrada"
    }
    
    func guarda() {
        do {
            try Disk.save(self.palabras, to: .applicationSupport, as: "diccionario.json")
        }
        catch {
            print("Error guardando")
        }
    }
    
    func lee() {
        do {
            try self.palabras = Disk.retrieve("diccionario.json", from: .applicationSupport, as: [Palabra].self)
        }
        catch {
            print("Error leyendo")
        }
    }
}

AppDelegate.swift

//
//  AppDelegate.swift
//  Traductor
//

import UIKit

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
    
    var diccionario = Diccionario()
    
    var window: UIWindow?

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        
        self.diccionario.lee()
        
        return true
    }

    func applicationWillResignActive(_ application: UIApplication) {
    }

    func applicationDidEnterBackground(_ application: UIApplication) {
    }

    func applicationWillEnterForeground(_ application: UIApplication) {
    }

    func applicationDidBecomeActive(_ application: UIApplication) {
    }

    func applicationWillTerminate(_ application: UIApplication) {
    }
}

FirstViewController.swift

//
//  FirstViewController.swift
//  Traductor
//

import UIKit

class FirstViewController: UIViewController {

    var diccionario : Diccionario! = nil
    
    @IBOutlet var traduccion: UILabel!
    @IBOutlet var entrada: UITextField!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        let appDelegate = UIApplication.shared.delegate as! AppDelegate
        
        self.diccionario = appDelegate.diccionario
        
        print(self.diccionario.traduce("dog"))
    }

    @IBAction func traducir(_ sender: UITextField) {
        traduccion.text! = self.diccionario.traduce(sender.text!)
    }
}

SecondViewController.swift

//
//  SecondViewController.swift
//  Traductor
//

import UIKit

class SecondViewController: UIViewController, UITableViewDataSource, UITableViewDelegate {

    @IBOutlet var palabras: UITableView!

    var diccionario : Diccionario! = nil

    override func viewDidLoad() {
        super.viewDidLoad()
        
        self.palabras.dataSource = self
        self.palabras.delegate = self

        let appDelegate = UIApplication.shared.delegate as! AppDelegate
        
        self.diccionario = appDelegate.diccionario
    }

    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return diccionario.palabras.count
    }
    
    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let cell = UITableViewCell(style: UITableViewCell.CellStyle.default, reuseIdentifier: "cell")
        cell.textLabel?.text = diccionario.palabras[indexPath.row].es + ", " + diccionario.palabras[indexPath.row].en
        return cell
    }
    
    @IBAction func addPalabra(_ sender: UIButton) {
        let alert = UIAlertController(title: "Añadir palabra", message: "", preferredStyle: .alert)
        
        alert.addTextField { (UITextField) in
            UITextField.placeholder = "Palabra en español"
        }

        alert.addTextField { (UITextField) in
            UITextField.placeholder = "Palabra en inglés"
        }
        
        alert.addAction(UIAlertAction(title: "Añadir", style: .default, handler: { (UIAlertAction) in
            let es = alert.textFields![0] as UITextField
            let en = alert.textFields![1] as UITextField
            self.diccionario.add(Palabra(es:es.text!, en:en.text!))
            self.diccionario.guarda()
            self.palabras.reloadData()
        }))
        
        alert.addAction(UIAlertAction(title: "Cancelar", style: .destructive, handler: nil))
        
        self.present(alert, animated: true, completion: nil)
    }
}

Cómo borrar palabras del diccionario

func tableView(_ tableView: UITableView, commit editingStyle: UITableViewCell.EditingStyle, forRowAt indexPath: IndexPath)
{
    if editingStyle == UITableViewCell.EditingStyle.delete {
        self.diccionario.palabras.remove(at: indexPath.row)
        self.diccionario.guarda()
        self.palabras.reloadData()
    }
}

Introducción

Como hemos comentado previamente, una de las ventajas que nos da Swift es la posibilidad de escribir código seguro. Esto implica que swift está preparado para que las aplicaciones no se encuentren con situaciones indeseadas al momento de ejecutar el código. Los opcionales son un mecanismo muy importante para conseguir este objetivo.

Los opcionales permiten indicar que un valor puede estar ausente. Esto significa que una variable opcional puede tener un valor y por lo tanto se puede acceder al mismo o que esa variable esta “vacía”.

La potencia de este enfoque es que si se sabe que una variable puede llegar a no tener valor en algún momento de su ciclo de vida, podemos escribir código adicional preguntando si ese valor existe o no, estando seguros en todo momento sobre qué hacer en cada caso.

Si no existieran los opcionales, puede darse el caso de que no contemplemos un escenario en donde el valor no exista y por lo tanto se generen comportamientos extraños en momentos de ejecución. Veamos un ejemplo:

let colores = ["azul", "negro", "verde", "rojo", "amarillo"]

let primerColor = colores.first

//primerColor es es String? en lugar de String

Primero definimos un array de String donde guardamos un listado de colores y luego, creamos una constante para obtener el primero color del arreglo usando la propiedad first.

Como puede darse el caso de que el array esté vacío, first no siempre va a devolver un valor; en algunos casos tomará el primer elemento pero en otros indicará que no se encontró un valor. Esto hace que el resultado sea un opcional.

nil

Volviendo al ejemplo anterior, para indicar la ausencia de un valor se usa un valor especial llamado nil.

Por lo tanto, la constante primerColor no se trata de un tipo String sino de un opcional de String, indicado con un signo de pregunta (?) String?.

Si quisiéramos definir una variable como opcional usamos la siguiente forma:

var segundoColor: String? = "negro"
print("\(segundoColor)")

//Devuelve:
//Optional(“negro”)

segundoColor = nil
print("\(segundoColor)")

//Devuelve:
//nil

Como vemos, definimos la variable indicando el tipo de dato y agregando un signo de pregunta para indicar que se trata de un opcional.

La asignación de un valor en ese momento es optativo, ya que de no hacerlo Swift infiere que su valor inicial es nil.

Si imprimimos esa variable usando print vemos que su valor es Optional(“negro”) en lugar de “negro” a secas.

Una variable opcional puede volver a valer nil si es necesario.

Recordemos que las variables no opcionales deben tener un valor al momento de su definición obligatoriamente.

Forced unwrapping

Si sabemos y estamos seguros que en un determinado momento una variable opcional tiene un valor en su interior, podemos usar la técnica de forced unwrapping (desenvoltura forzada) mediante el uso de un signo de exclamación al final del nombre de la variable (!):

var otroColor:String? = "celeste"
print(“\(otroColor!)”)
//Devuelve
//celeste

Como sabemos que la variable otroColor contiene un valor, usamos la desenvoltura forzada y accedemos al dato que el mismo encierra. Ya no estamos obteniendo un Optional(“celeste”) sino que directamente obtenemos “celeste”.

Si quisiéramos preguntar primero si esa variable vale nil o no, una posibilidad es usar una sentencia if:

if otroColor != nil {
    print("\(otroColor!)")
}

//Devuelve
//celeste

En este caso, primero nos aseguramos si la variable no vale nil (o sea, si tiene un valor) y luego hacemos el forced unwrapping, debido a que dentro del ifestamos seguros que esa variable tiene un valor.

Optional Binding

Si bien el enfoque anterior es perfectamente válido, no termina siendo muy cómodo si dentro del if se necesita usar muchas veces el valor dentro del opcional, ya que tendríamos que recordar de usar el ! en todos los casos.

Otra manera de hacer lo mismo pero un poco más eficiente es usando el optional binding (enlace opcional), en el cual se pregunta si un opcional contiene un valor y en caso afirmativo, se crea una constante o variable temporal para ser usada dentro del if o while como si se tratara de una versión no opcional. Una vez fuera de ese if o while, la misma deja de existir.

if let colorElegido = otroColor {
    print("El color elegido es \(colorElegido)")
}

//Devuelve:
//El color elegido es celeste

Como vemos, creamos una constante temporal llamada colorElegido que contiene el valor del opcional otroColor. Dentro del if usamos ese valor y ya fuera de él la constante ya no existe más.

Asimismo, podemos anidar varios enlaces opcionales e incluso usar otras comparaciones convencionales que devuelven true o false. Como resultado, sólo se ejecutarán las instrucciones dentro del if cuando todos los opcionales tengan un valor y todas las condiciones devuelvan true. Si alguno de estos casos no se da, el resultado final será false y no se ingresará al if.

let numeroPar = 30

if let colorElegido = otroColor, let numero = Int("45"), numeroPar < 50 {
    print("El color elegido es \(colorElegido) y el \(numeroPar) es menor a 50")
    print("\(numero)")
}

//Devuelve:
//El color elegido es celeste y el 30 es menor a 50
//45

Implicit unwrapped optionals

En muchas situaciones contamos con variables opcionales que en un momento determinado del programa son inicializados con un valor y que luego no van a volver a valer nil nunca más. Por tal motivo, es conveniente no tener que preguntar a cada instante si esa variable contiene un valor y hacer la desenvoltura correspondiente, ya que se asume que siempre se va a contener un valor.

Un ejemplo muy claro de este escenario se da cuando se programa para un sistema operativo como iOS, en donde los botones que vemos en pantalla al inicio de su ciclo de vida se crean en nil pero luego mientras se inicializan determinados componentes, las variables que hacen referencia a esos botones contienen valor, hasta tanto el usuario cambia de pantalla y se pierden esas referencias. Como en un momento de su ciclo de vida necesitó valer nil, es obligatorio usar un opcional, pero como luego siempre va a tener un valor, no es cómodo tener que usar un if let en cada uso. Para este tipo de casos, los implicity unwrapped optionals (opcionales desenvueltos en forma implícita) son ideales.

Para hacer uso de ellos, en lugar de declarar al opcional usando un signo de pregunta (?) se utiliza un signo de exclamación (!):

let posibleValor:String? = "Estamos aprendiendo Swift! Yeahh!"
let valorSeguro:String! = posibleValor!

print(posibleValor)
print(valorSeguro)

//Devuelve:
//Optional("Estamos aprendiendo Swift! Yeahh!")
//Estamos aprendiendo Swift! Yeahh!

Podríamos decir que este tipo de opcionales tienen realizan la desenvoltura de su valor en forma automática, sin necesidad de hacerlo explícito. Tengamos en cuenta que si una variable o constante vale nil e intentamos usar su valor, vamos a tener un error en tiempos de ejecución. Por lo tanto, hay que ser muy cuidadoso y pensar bien antes de usar este tipo de opcionales.

En el caso de que exista alguna posibilidad de que una variable se vuelva nil en algún momento del código, entonces no debemos usar este opcional implícito.

Por otro lado, si necesitamos preguntar si ese opcional implícito tiene un valor en su interior o si quisiéramos usar el optional binding, podemos hacerlo:

if valorSeguro != nil {
    print(valorSeguro)
}

if let dato = valorSeguro {
    print(dato)
}

nil-coalescing operator

Este operador, que podríamos traducirlo como operador que viene junto a nil, devuelve el valor que contiene un opcional haciendo una desenvoltura (a) y en caso de encontrar nil, devuelve otro valor (b). Su sintaxis es a ?? b.

Un punto a tener en cuenta es que tanto a como b deben ser del mismo tipo.

var animal:String? = "Perro"

let mascota = animal ?? "Gato"

print("\(mascota)")

//Devuelve Perro

En el ejemplo, definimos una variable opcional animal con el valor Perro. Al ser opcional, podría no contener un valor (ser nil). Luego se declara una constante mascota que va a valer Perro siempre que la variable animal tenga ese valor. En caso de ser nil, se incluye un valor adicional Gato.

Este operador es muy útil cuando queremos dar un valor por defecto en caso de que una variable o contante no tengan valor.

Definición

Las enumeraciones son un tipo de dato que permiten definir un grupo de valores relacionados bajo un nombre. Cada uno de estos valores dentro de la enumeración son llamados miembros o casos y poseen a su vez, un nombre que los identifica. Esto es, al definir una enumeración, se establecen los posibles estados que ese enum puede llegar a valer. Todos esos estados, o miembros, están relacionados entre sí.

Por ejemplo, si quisiera crear una variable sobre los puntos cardinales sabemos que, en principio, tiene cuatro posibles valores: Norte, Sur, Este y Oeste. Esos cuatro valores podrían ser miembros de un enum llamado PuntosCardinales y la variable a crear podría tomar uno de esos estados.

Sintaxis de las enumeraciones en Swift

Para definir una enumeración se utiliza la palabra reservada enum seguida del nombre de la misma.

Luego, el cuerpo de la enumeración se encierra entre llaves, como vemos a continuación:

enum Enumeracion {
    //Cuerpo de la enumeración
}

Para definir los miembros de una enumeración, se utiliza la palabra reservada case. Siguiendo el ejemplo de los puntos cardinales, su estructura sería la siguiente:

enum PuntoCardinal {
    case norte
    case sur
    case este
    case oeste
}

A su vez, cada caso puede definirse en una sola línea, usando una sola vez la palabra case y separando cada miembro por comas:

enum PuntoCardinal {
    case norte, sur, este, oeste
}

Convención de nombres para las enumeraciones en Swift

Al igual que las clases y las estructuras, las enumeraciones también son tipos de datos que creamos en nuestro código. Por lo tanto, el nombre que le asignemos debe comenzar con una mayúscula y, en caso de ser varias palabras, cada una de ellas debe separarse por mayúsculas sin usar guiones bajos u otro símbolo (camel case).

Otro punto a considerar es que el nombre de la enumeración debe estar en singular y nunca en plural. Esto es así ya que las enumeraciones se usan dentro de variables o constantes, por lo tanto solo pueden adoptar 1 valor a la vez. Siguiendo el caso anterior, si creamos una variable para el punto cardinal tendríamos lo siguiente:

var direccion = PuntoCardinal.norte

La lectura de la asignación anterior es muy clara. Se está eligiendo un punto cardinal de un listado de posibles valores y dicho valor se está guardando en la variable dirección.

Uso de las enumeraciones en Swift

Como vimos, tanto las variables como las constantes pueden ser del tipo de una enumeración. En su asignación inicial, debemos especificar el nombre del enum que vamos a usar y el valor que va a tomar dentro de la enumeración.

Supongamos que tenemos la siguiente enumeración:

enum DiaDeLaSemana {
    case lunes, martes, miercoles, jueves, viernes, sabado, domingo
}

Una posible asignación a una variable podría ser la siguiente:

var mañana = DiaDeLaSemana.martes

Como la variable mañana se inicia por primera vez, debemos especificar que su valor va a ser alguno de los contenidos dentro de la enumeración DiaDeLaSemana. Sin embargo, si quisiéramos modificar su valor, ya no es necesario volver a indicar el tipo de dato:

mañana = .miercoles

Como ya sabemos que mañana es un DiaDeLaSemana, directamente podemos asignarle otro valor dentro del enum usando un punto y el nuevo valor.

Comparar valores de las enumeraciones en Swift

Durante nuestro código, una vez que tengamos una variable con un cierto valor de los disponibles de una enumeración, vamos a necesitar preguntar por él para tomar una decisión.

Comparar con if

Podemos usar if para conocer el valor de la variable:

if mañana == DiaDeLaSemana.lunes {
print(«Se termina el fin de semana!»)
}

Asimismo, tal como vimos antes, podemos simplificar el código anterior sin mencionar el tipo de dato:

if mañana == .lunes {
    print("Se termina el fin de semana!")
}

Comparar con switch

Sin embargo, si tenemos una enumeración con varios casos y deseamos codificar un comportamiento para cada uno, usar un if no va a ser la mejor opción. En esos casos, conviene usar switch:

switch mañana {
    case .lunes:
        print("Mañana es lunes")
    case .martes:
        print("Mañana es martes")
    case .miercoles:
        print("Mañana es miércoles")
    case .jueves:
        print("Mañana es jueves")
    case .viernes:
        print("Mañana es viernes")
    case .sabado:
        print("Mañana es sábado")
    case .domingo:
        print("Mañana es domingo")
}
//Devuelve
//Mañana es miércoles

Cómo comentamos en el capítulo de control de flujo, la sentencia Switch necesita que los casos sean exhaustivos, es decir, que se contemplen todos los posibles valores que esa variable pueda tomar. Como la enumeración DiaDeLaSemana solo tiene 7 casos posibles, no hay riesgo de que una variable de ese tipo adopte otro valor distinto a esos 7, por lo tanto no es necesario usar un default.

Sin embargo, si no hiciéramos mención a los 7 valores en los cases, deberíamos incluir un default:

switch mañana {
    case .lunes:
        print(“Mañana es lunes”)
    case .martes:
        print(“Mañana es martes”)
    case .miercoles:
        print(“Mañana es miércoles”)
    case .jueves:
        print(“Mañana es jueves”)
    case .viernes:
        print(“Mañana es viernes”)
    default:
        print(“Mañana comienza el fin de semana”)
}
//Devuelve
//Mañana es miércoles

Enumeraciones con métodos

Al igual que en las clases y structs, podemos definir métodos dentro de los enums. Esta característica muestra la flexibilidad que las enumeraciones tienen en Swift y lo diferencia con las implementaciones en otros lenguajes de programación.

Los métodos que escribamos dentro de un enum siguen las mismas reglas que vimos en el capítulo de funciones.

enum Saiyan {
    case Goku, Vegeta, Gohan, Trunks

    func superPoder() -> String {
        switch self {
            case .Goku, .Gohan:
                return "Kamehameha"
            case .Vegeta, .Trunks:
                return "Garlic Ho"
        }
    }
}

let principeSaiyan = Saiyan.Vegeta
print("\(principeSaiyan.superPoder())")

//Devuelve
//Garlic Ho

Introducción

En este capítulo vamos a ver uno de los conceptos más importantes de la programación orientada a objetos: las clases. Su importancia radica en que todo programador debe diseñar un modelo de datos que soporte el comportamiento que requiere un determinado programa para resolver el problema para el cual es creado y las clases son justamente ideales para ello. En el siguiente capítulo vamos a ver las estructuras que tienen un comportamiento similar a las clases, sobre todo en Swift.

Según Wikipedia una clase es “una plantilla para la creación de objetos de datos según un modelo predefinido. Las clases se utilizan para representar entidades o conceptos, como los sustantivos en el lenguaje. Cada clase es un modelo que define un conjunto de variables -el estado, y métodos apropiados para operar con dichos datos -el comportamiento. Cada objeto creado a partir de la clase se denomina instancia de la clase”.

Como bien dice la definición, usamos las clases para definir un concepto. Dicho concepto forma parte del problema que queremos modelar y por lo tanto, del problema que queremos resolver al crear un programa. Para ello, las clases poseen distintos componentes, entre los que se destacan las propiedades y los métodos. Podemos decir que las propiedades son las características que poseen las clases mientras que los métodos son las acciones que podemos realizar.

Cada vez que creamos una clase, en realidad estamos creando un nuevo tipo de dato. Es por esto que se dice que este tipo de lenguajes es un lenguaje tipado, por la posibilidad que da al programador de crear nuevos tipos. Todo nombre de una clase debe, por convención, nombrarse con una mayúscula en su primer letra, mientas que las propiedades y métodos deben comenzar con minúscula.

Sintaxis de una clase

Para crear una clase se utiliza la palabra reservada class seguida del nombre de la misma:

class UnaClase {
}

Las propiedades son variables o constantes creados dentro del ámbito de una clase y su declaración sigue todas las reglas que vimos en los capítulos anteriores.

class Rectangulo {
    let lados = 4
    let alto = 5
    let ancho = 2
}

let figura = Rectangulo()
print("la figura contiene \(figura.lados) lados")

//Devuelve
//la figura contiene 4 lados

Como se aprecia en el ejemplo, para poder instanciar una clase basta con declarar una variable o constante y hacer una asignación usando el nombre de esa clase. En este caso, se usan paréntesis sin parámetros porque no se ha especificado que reciba ninguno. La clase Rectángulo posee tres propiedades numéricas con un valor asignado al momento de la creación de la clase.

Se dice que la constante figura representa un objeto o una instancia de la clase Rectángulo. La diferencia entre una clase y un objeto (o instancia) es que la clase simplemente es una definición, un concepto. Sin embargo, al momento de crear el objeto, se asigna un espacio en memoria para poder guardar todos los elementos que este define y por lo tanto, sus propiedades y métodos pueden ser usados.

Gracias a que figura es una instancia (y no una simple definición como lo es Rectángulo), podemos acceder a su propiedad lados e imprimir el resultado dentro de una cadena con la función print.

Inicialización de una clase

Si quisiéramos que las propiedades de la clase obtengan su valor al momento de crear la instancia, debemos utilizar un inicializador (lo que en otros lenguajes orientados a objetos se lo conoce como constructor). Mediante este elemento podremos, en el ejemplo, dar un valor a las propiedades alto y ancho para crear distintos tamaños de rectángulos al momento de crear una instancia.

Se define inicialización como el proceso de preparar la instancia de una clase. En él, podemos dar valores iniciales a las propiedades de la clase como así también ejecutar código para hacer un seteo inicial. Para poder usarlo, debemos usar un inicializador que se identifica por la palabra reservada init.

class Rectangulo {
    let lados = 4
    var alto:Int
    var ancho:Int

    init(al:Int, an:Int){
        alto = al
        ancho = an
    }
}

let figura = Rectangulo(al: 3, an: 6)
print("La figura mide \(figura.alto) x \(figura.ancho)")

//Devuelve:
//La figura mide 3 x 6

En el ejemplo usamos init para establecer un valor inicial para las propiedades alto y ancho. Luego, en el cuerpo del mismo usamos esos parámetros para asignárselos a las propiedades. Como se puede observar en el print, los valores se guardan en las variables correspondientes.

En el proceso de inicialización, no solamente se puede dar un valor inicial a las variables. Por el contrario, las constantes también pueden ser inicializadas aquí teniendo en cuenta que una vez que termine el proceso de init, las mismas deben quedar todas inicializadas (no pueden haber constantes sin valor) y luego nunca más podrán variar su contenido. Si quedaran constantes sin inicializar, se obtendría un error.

En el caso de querer dejar una variable sin inicializar incluso cuando ya finalizó la etapa del init, esa variable deberá ser un opcional, ya que en su ciclo de vida existen etapas donde su valor es nil.

Self

Si bien el ejemplo anterior obtiene perfectamente dos valores y los mismos son usados dentro del cuerpo del init, el nombre de los parámetros no siguen los criterios de nomenclatura que promueve Apple. Uno de los puntos más importantes de estos criterios es que el nombre de las variables, parámetros, constantes o cualquier otra estructura que usemos debe dar una idea del valor que contiene o del propósito para el cual fue creado.

En este sentido, los nombres utilizados para los parámetros del ejemplo (al y an) no dicen nada, y una persona que use nuestro código (o bien nosotros mismos más adelante) puede no entender de qué se trata. Por eso, sería más conveniente darles nombres más descriptivos, como alto y ancho respectivamente.

Ahora bien, ¿cómo diferenciamos las referencias alto y ancho de los parámetros con respecto al alto y ancho de las propiedades? Es decir, si en el cuerpo del init hiciéramos un “alto + alto”, ¿estaríamos haciendo referencia a la suma de los alto de los parámetros o de las propiedades?

Para evitar esta confusión existe la palabra reservada self. Con self hacemos referencia a los nombres de las propiedades de la clase. Por lo tanto, dentro de un init en donde el nombre de los parámetros coincide con el de las propiedades, decir self.alto hace referencia al alto de las propiedades, mientras que alto a secas referencia al parámetro.

Dicho esto, el siguiente ejemplo queda mucho más claro en cuanto a los nombres de los parámetros:

class Rectangulo {
    let lados = 4
    var alto:Int
    var ancho:Int

    init(alto:Int, ancho:Int){
        self.alto = alto
        self.ancho = ancho
    }
}

let figura = Rectangulo(alto: 3, ancho: 6)
print("La figura mide \(figura.alto) x \(figura.ancho)")

//Devuelve:
//La figura mide 3 x 6

Métodos de una clase

Los métodos son funciones escritas dentro del cuerpo de una clase que permiten darle un comportamiento a ésta, encapsulando tareas y proveyendo de un comportamiento a la instancia.

En Swift los métodos no son un componente exclusivo de las clases sino que también se pueden dotar de métodos a las estructuras y enumeraciones, como veremos más adelante.

Para crear un método, basta con crear una función dentro de la clase:

class Rectangulo {
    let lados = 4
    var alto:Int
    var ancho:Int

    init(alto:Int, ancho:Int){
        self.alto = alto
        self.ancho = ancho
    }

    func incrementarAlto() {
        alto += 1
    }
}

let figura = Rectangulo(alto: 3, ancho: 6)
figura.incrementarAlto()
print("La figura mide \(figura.alto) x \(figura.ancho)")

//Devuelve:
//La figura mide 4 x 6

En el ejemplo anterior, creamos un método que nos permite aumentar el alto del rectángulo en 1. Por lo tanto, al invocar a la función incrementarAlto() el valor de la propiedad Alto sube a 4.

Cabe destacar que los métodos siguen todas las reglas que vimos en el capítulo de funciones. Por consiguiente, podemos crear métodos con el mismo nombre pero distinta definición generando sobrecarga o usar etiquetas de argumento, por solo citar dos características:

class Rectangulo {
    let lados = 4
    var alto:Int
    var ancho:Int

    init(alto:Int, ancho:Int){
        self.alto = alto
        self.ancho = ancho
    }

    func incrementarAlto() {
        alto += 1
    }

    func incrementarAlto(en valor: Int) {
        alto += valor
    }
}

let figura = Rectangulo(alto: 3, ancho: 6)
figura.incrementarAlto(en: 6)
print("La figura mide \(figura.alto) x \(figura.ancho)")

//Devuelve:
//La figura mide 9 x 6

Herencia

Se trata de una propiedad que permite que una clase se cree a partir de otra, adoptando las características de la clase madre y agregando nuevas funcionalidades. Es especialmente útil cuando se elabora el diagrama de clases que se va a utilizar para resolver un problema determinado y que, consiguientemente, van a definir el comportamiento de la aplicación. Una clase puede heredar métodos, propiedades y otras características de la otra clase.

La herencia es una de las propiedades que diferencia a las clases de otros tipos, como las estructuras o las enumeraciones. Cuando una clase A hereda de B se dice que B es la súper clase y A la subclase.

Las subclases, por lo tanto, pueden hacer uso de la funcionalidad de la súper clase como si dicha funcionalidad se hubiera definido dentro de ella. Asimismo, la subclase puede sobreescribir las versiones de los métodos o propiedades en caso de ser necesario (proceso conocido como overriding).

Clase base

Se define clase base como aquella que no hereda de ninguna otra. Supongamos que tenemos la siguiente clase FiguraGeometrica:

class FiguraGeometrica {
    var color:String
    var area = 0.0
    var perimetro = 0.0

    init(color:String) {
        self.color = color
    }

    func calcularArea() {
        //No escribimos nada ya que cada figura tiene su propia fórmula
    }

    func calcularPerimetro() {
        //No escribimos nada ya que cada figura tiene su propia fórmula
    }

    func cambiar(color:String) {
        self.color = color
    }
}

En el ejemplo, la clase FiguraGeometrica define 3 propiedades: color, área y perímetro. El color es asignado en el init mientras que los otros dos son iniciados en 0. Por otro lado, se definen 3 métodos, pero dos de ellos no tienen código en su interior debido a que no disponen de los datos suficientes para poder hacer el cálculo, ya que cada figura geométrica posee su propia fórmula para calcular estas propiedades. Mientras tanto, lo único que sí sabemos a esta altura es que si se desea cambiar el color, simplemente recibiendo un nuevo color ya es suficiente para hacer el cambio.

La primera conclusión que sacamos es que en la clase base debemos incluir aquellas propiedades y métodos que son comunes en todas las clases heredadas.

Al momento de crear la clase FiguraGeometrica definimos todas las características comunes para una figura geométrica arbitraria. Para darle más comportamiento y un contexto más rico, es necesario crear clases más específicas que hereden de ella.

Para representar colores en una aplicación real se utilizan otras clases en lugar de String, pero para efectos del ejemplo vamos a usarlos como si solo se trataran de cadena de caracteres.

Subclases

Como ya dijimos, al crear una subclase se genera una nueva clase basada en otra, de la cual se heredan sus características. Estas pueden ser usadas como si fueran propias, pueden ser modificadas e incluso pueden agregarse nuevas características.

Para indicar que una subclase hereda de otra, se lo debe indicar al momento de definirla, usando : y el nombre de la súper clase:

class subClase: superClase {

}

Podemos tomar la clase Rectángulo usada en los ejemplos anteriores y hacer que herede de FiguraGeometrica:

class Rectangulo:FiguraGeometrica {
    let lados = 4
    var alto:Int
    var ancho:Int

    init(color:String, alto:Int, ancho:Int){
        self.alto = alto
        self.ancho = ancho
        super.init(color: color)
    }

    func incrementarAlto() {
        alto += 1
    }

    func incrementarAlto(en valor: Int) {
        alto += valor
    }
}

Un punto a tener en cuenta es que la súper clase tiene un inicializador distinto al de la subclase (espera un color mientras que la subclase espera un alto y un ancho). Por lo tanto, en el init de la clase Rectángulo se debe invocar al init de la súper clase como última sentencia, utilizando la palabra reservada super.

let rectangulo = Rectangulo(color: "Azul", alto: 9, ancho: 4)
print("El rectángulo mide \(rectangulo.alto) x \(rectangulo.ancho) y es de color \(rectangulo.color)")

//Devuelve:
//El rectángulo mide 9 x 4 y es de color Azul

Como se aprecia en el ejemplo, la variable rectángulo es una instancia de la clase Rectángulo y si bien la propiedad color pertenece a la súper clase, se utiliza como si hubiera sido definido dentro de la sub clase.

De la misma manera, se pueden crear otras subclases adicionales:

class Circulo:FiguraGeometrica {
    var radio: Double

    init(color: String, radio:Double) {
        self.radio = radio
        super.init(color: color)
    }
}

Una clase puede tener n cantidad de subclases, pero una subclase solo puede tener una súper clase.

Override

En el proceso de override se sobreescriben las funcionalidades de los métodos (lo mismo de las propiedades) para proveer una implementación alternativa en la subclase.

class Rectangulo:FiguraGeometrica {
    let lados = 4
    var alto:Int
    var ancho:Int

    init(color:String, alto:Int, ancho:Int){
        self.alto = alto
        self.ancho = ancho
        super.init(color: color)
    }

    func incrementarAlto() {
        alto += 1
    }

    func incrementarAlto(en valor: Int) {
        alto += valor
    }

    override func calcularArea() {
        area = Double(alto) * Double(ancho)
    }

    override func calcularPerimetro() {
        perimetro = 2 * Double(alto) + 2 * Double(ancho)
    }
}

class Circulo:FiguraGeometrica {
    var radio: Double

    init(color: String, radio:Double) {
        self.radio = radio
        super.init(color: color)
    }

    override func calcularArea() {
        area = Double.pi * radio * radio
    }

    override func calcularPerimetro() {
        perimetro = 2 * Double.pi * radio
    }
}

Tanto la clase Rectangulo como Circulo ahora tienen sus propias implementaciones de los métodos calcularArea() y calcularPerimetro(), los cuales difieren entre sí ya que sus fórmulas son distintas. Para sobreescribir la versión de la súper clase se usa la palabra reservada override.

let circulo = Circulo(color: "verde", radio: 6.43)
circulo.calcularArea()
circulo.calcularPerimetro()
print("El area del círculo es \(circulo.area) y el perimetro es \(circulo.perimetro)")

//Devuelve:
//El area del círculo es 129.888834103405 y el perímetro es 40.4008815251647

Ejemplos completos

class UnaClase {
    
}

class Rectángulo1 {
    let lados = 4
    let alto = 5
    let ancho = 2
}

let figura1 = Rectángulo1()
print("la figura contiene \(figura1.lados) lados")
//Devuelve
//la figura contiene 4 lados

class FiguraGeometrica {
    var color:String
    var area = 0.0
    var perimetro = 0.0
    
    init(color:String) {
        self.color = color
    }
    
    func calcularArea() {
        //No escribimos nada ya que cada figura tiene su propia fórmula
    }
    
    func calcularPerimetro() {
        //No escribimos nada ya que cada figura tiene su propia fórmula
    }
    
    func cambiar(color:String) {
        self.color = color
    }
    
}


class Rectángulo2 {
    let lados = 4
    var alto:Int
    var ancho:Int
    
    init(alto:Int, ancho:Int){
        self.alto = alto
        self.ancho = ancho
    }
    
    func incrementarAlto() {
        alto += 1;
    }
    
    func incrementarAlto(en valor: Int) {
        alto += valor;
    }
}

let figura = Rectángulo2(alto: 3, ancho: 6)
figura.incrementarAlto()
figura.incrementarAlto(en: 6)
print("La figura mide \(figura.ancho) x \(figura.alto)")
//Devuelve:
//La figura mide 6 x 3


/*class subClase: superClase {
    
}
*/


class Rectángulo:FiguraGeometrica {
    let lados = 4
    var alto:Int
    var ancho:Int
    
    init(color:String, alto:Int, ancho:Int){
        self.alto = alto
        self.ancho = ancho
        super.init(color: color)
    }
    
    func incrementarAlto() {
        alto += 1;
    }
    
    func incrementarAlto(en valor: Int) {
        alto += valor;
    }
    
    override func calcularArea() {
        area = Double(alto) * Double(ancho)
    }
    
    override func calcularPerimetro() {
        perimetro = 2 * Double(alto) + 2 * Double(ancho)
    }
}

let rectangulo = Rectángulo(color: "Azul", alto: 9, ancho: 4)
print("El rectángulo mide \(rectangulo.ancho) x \(rectangulo.alto) y es de color \(rectangulo.color)")
//Devuelve:
//El rectángulo mide 4 x 9 y es de color Azul

class Círculo:FiguraGeometrica {
    var radio: Double
    
    init(color: String, radio:Double) {
        self.radio = radio
        super.init(color: color)
    }
    
    override func calcularArea() {
        area = Double.pi * radio * radio
    }
    
    override func calcularPerimetro() {
        perimetro = 2 * Double.pi * radio
    }
}

let círculo = Círculo(color: "verde", radio: 6.43)
círculo.calcularArea()
círculo.calcularPerimetro()
print("El area del círculo es \(círculo.area) y el perímetro es \(círculo.perimetro)")
//Devuelve:
//El area del círculo es 129.888834103405 y el perímetro es 40.4008815251647