Swift: Una introducción

• Seguro• Moderno• Potente

Sergio González Linares @sergiogl_ Desarrollador iOS y web

Algunas características (I)• Nuevo lenguaje de programación para el desarrollo de

aplicaciones en iOS y OS X.• Desarrollado a lo largo de 4 años.• Basado en C y Objective-C, sin sus restricciones.• Sintaxis sencilla, similar a otros lenguajes.• Curva de aprendizaje menor que Objective-C.• Gestión de memoria con Reference Automatic Counting (ARC).• Interoperabilidad mix-and-match con el código en Objective-C.• Soporta playgrounds.

Algunas características (II)• Los nombres de constantes y variables pueden incluir casi

cualquier carácter, incluyendo caracteres Unicode.• Permite anidar comentarios multilínea (/* */).• El punto y coma al final de las sentencias es opcional.• Los paréntesis en las condiciones son opcionales.• Se pueden definir alias para tipos de datos existentes mediante

typealias.• Nil no es un puntero a un objeto inexistente. Indica la ausencia

de valor.

Constantes y variables. Inferencia de tipos

var miVariableInt = 10 var miVariableFloat = 10.0

let miConstante = 5 let π = 3.1415927

var miCadena: String var miDoubleExplicito: Double = 10

Constantes:

Variables:

Especificando tipo:

Conversión de tipos: let mensaje = “Su peso es “ let peso = 60 let mensajeCompleto = mensaje + String(peso)

Cadenas.Arrays y diccionarios

let cervezas = 5 let calimochos = 7 let mensaje = “Me he bebido \(cervezas + calimochos) copas. ¡Hip!”

Las cadenas (Strings) son ahora un tipo por valor.

Se pueden concatenar con + y comparar con ==.

Permiten incluir valores y operaciones:

Arrays: let arrayVacio = String[]() let arrayInferido = [] var arrayMutable = [“Alfa”, “Bravo”, “Charlie”, “Urdangarín”] arrayMutable[3] = “Delta”

Diccionarios: let diccionarioVacio = Dictionary<String, Int>() let diccionarioInferido = [:] var diccionarioMutable = [“Objective-C”: 1980, “Java” : 1995] diccionarioMutable[“Swift”] = 2014

Tuplas y opcionales

let unPokemon = (25, “Pikachu”) println (“El pokémon número \(unPokemon.0) se llama \(unPokemon.1)”) !let (num, nombre) = unPokemon println (“El pokémon número \(num) se llama \(nombre)”) !let otroPokemon = (num: 4, nombre: “Charmander”) println (“El pokémon número \(otroPokemon.num) se llama \(otroPokemon.nombre)”)

Las tuplas permiten agrupar dos o más valores, del mismo o de distinto tipo, en un único valor compuesto:

Los opcionales son valores que pueden existir… o no:

let personajes = [“Gandalf”: “Mago”, “Bilbo”: “Pícaro”, “Thorin”: “Guerrero”] !let clase: String? = personajes[“Tauriel”] if clase { println(“Tauriel es de clase \(clase)”) } else { println(“¿Quién demonios es Tauriel?”) }

Funciones (I)func saludar(nombre: String) -> String { return “Ola k ase, “ + nombre }

Función que devuelve un valor:

func sumar(sumando1: Int, sumando2: Int) -> Int { return sumando1 + sumando2 }

Función con varios parámetros:

func despedirse() -> String { return “Me las piro vampiro” }

Función sin parámetros:

func cantar() { println(“Échame una mano, prima, que viene mi novio a verme...”) }

Función que no devuelve ningún valor:

Funciones (II)func descomponer(valor: Float) -> (parteEntera: Int, parteDecimal: Float) { let parteEntera = Int(valor) let parteDecimal = valor - Float(parteEntera) return (parteEntera, parteDecimal) } !let (parteEntera, parteDecimal) = descomponer (3.1415927)

Función que devuelve múltiples valores:

func unirCadena(cadena s1:String, conCadena s2:String) -> String { return s1 + s2 } !unirCadena (cadena: “Hola ”, conCadena: “caracola”)

Función con parámetros con nombres externos:

func incrementar(numero: Int, incremento: Int = 1) -> Int { return numero + incremento }

Parámetros con valores por defecto:

Closures (Clausuras)

let saludoConClausura = { println (“Hola, soy una clausura”) } !saludoConClausura()

Una clausura es un bloque autocontenido con una función determinada, que puede usarse en cualquier parte de nuestro código. Es un concepto similar a los bloques de C.

func repetir(veces: Int, tarea: () -> ()) { for i in 0..veces { tarea() } } !repetir (4, saludoConClausura()) repetir (4, { println (“Hola, directamente desde código”) }) repetir (4) { println (“Hola, clausura fuera de los parámetros”) }

Las clausuras se pueden utilizar como parámetros en otras funciones:

Clases (I)• No es necesario heredar de ninguna superclase.• ¿Archivos de cabecera? ¿Eso qué es?• Las instancias gestionan su memoria automáticamente. No más

new, alloc ni init.class Vehículo { var númeroDeRuedas = 0 }

class Vehículo { var númeroDeRuedas = 0 var descripción: String { get { return “Este vehículo tiene \(númeroDeRuedas) ruedas” } } }

Una clase puede incluir propiedades calculadas (computed properties):

Clases (II)

class Vehículo { var númeroDeRuedas = 4 var descripción: String { return “Este vehículo tiene \(númeroDeRuedas) ruedas.” } }

Cuando una propiedad calculada es de sólo lectura, nos podemos ahorrar el get:

var miCarro = Vehículo() println (miCarro.descripción)

Crear una instancia de la clase y acceder a sus propiedades no podría ser más sencillo:

Clases (III)

class Bicicleta: Vehículo { init() { super.init() númeroDeRuedas = 2 } } !let miBici = Bicicleta() println (miBici.descripción)

Aunque no sea necesario, las clases siguen pudiendo heredar unas de otras.

Cuando una clase hereda de una superclase y modifica las propiedades heredadas, es necesario crear un inicializador.

Clases (IV)

class Coche: Vehículo { ! var velocidad = 0.0 ! init() { super.init() númeroDeRuedas = 4 } ! override var descripción: String { return super.descripción + “, y corre a \(velocidad) km/h” } } !let miCoche = Coche() println (miCoche.descripción)

Al igual que las propiedades, también se pueden redefinir los métodos. Para ello se utiliza la palabra override antes de la declaración del método.

Clases (V)

class CocheDeCani: Coche { ! override var velocidad: Double { willSet { if newValue > 120.0 { velocidad = 0.0 println (“Unos tíos de verde te han puesto una multa, por listo”) } } didSet { if oldValue <= 120.0 { println (“Antes ibas bien, ganso”) } } } }

Una de las novedades más importantes son los observadores de propiedades.

Estos observadores permiten reaccionar ante los cambios en las propiedades de una instancia:

Genéricos

struct Pila<T> { ! var elementos = T[]() ! mutating func push(elemento: T) { elementos.append(elemento) } ! mutating func pop() -> T { return elementos.removeLast() } } !var pilaCadenas = Pila<String>() pilaCadenas.push(“Lolailo”) println (pilaCadenas.pop())

Los genéricos permiten crear una funcionalidad cualquiera, independientemente del tipo de datos que se vayan a manejar con ella.

Playgrounds• Los playgrounds son un nuevo tipo de simulador que permite

modificar nuestro código y ver inmediatamente los cambios.• Podemos observar de forma gráfica los cambios en el tiempo a

través de una línea temporal o timeline.• Los playgrounds permiten:

✓ Enseñar a otros a programar de forma sencilla, pudiendo ver los resultados de lo que hacen en tiempo real.

✓ Diseñar nuevos algoritmos y comprobar sus resultados inmediatamente.

✓ Crear tests y validar su funcionamiento antes de integrarlos en una batería de tests.

Recursos• Página oficial:

https://developer.apple.com/swift/• Libro gratuito disponible en iBooks.• Videos for Enterprise App Developers:

https://developer.apple.com/videos/enterprise/• LearnSwift.tips:

http://www.learnswift.tips• Learn Swift online:

http://www.learnswiftonline.com• Swift language highlights: An Objective-C developers perspective:

http://www.macsfan.com/codes/swift-language-highlights-objective-c-developers-perspective/

• Swift Cheat Sheet:http://kpbp.github.io/swiftcheatsheet/

• iOS Blogs Swift tutorials:http://ios-blog.co.uk/swift-tutorials/

Se acabó