Curso de Swift - Arturo Jamaica mejorando.la/ios

1. Arturo Jamaica
Introducción a Swift

2. Contenido
• Lo básico : Variables,
Constantes, Tipado, Strings,
Colecciones
• Operadores, Funciones y
Controladores de Flujo Clases y
propiedades
• Closures, Chaining
• Clases
• Memory management
Initialization
• Swift Playgrounds
• Xcode con Storyboard
• Autolayout y nuevo modelo de
Resizing de apps
• Primera app ios con Swift
• Swift usando cosas de Objective C
• Cocoapods *
• MVCD : Modelo - Vista - Controlador -
Delegate - Datasource *
• Controladores : UITableViewControllers,
UINavigationController,
UITabbarController y UIController *
• Modelos y Parse *

3. Por que Swift y no empezar
con Objective C
• Es más fácil de entender. Mucho más
• Por que Apple realmente esta comprometido en apoyarlo
• Por que no es obligatorio usarlo ni hay que migrar nada a
lo nuevo
• Es excelente para aprender
• Reduce el tamaño de los proyectos, en un 25%
• Toda el API de Apple lo soporta y es totalmente
retrocompatible.

4. Por que NO Swift y mejor
empezar con Objective C
• Por que no hay documentación completa aún en
sitios conocidos. Creemosla!
• Por que al googlear solo hay cosas de Taylor y
códigos interbancarios
• Por que al final uno termina aprendiendo
Objective C al mismo tiempo.

6. Pero…

7. SwiftObjective C
Menos código = Menos bugs

8. A considerar
• Swift es una versión final, Xcode ni IOS 8 lo son
• Hay bugs conocidos en los betas. (Yo uso el Beta
2 de XCode)
• Es posible que muchas cosas de Apple esten en
NDA. Revise todo para que lo que esté aquí no lo
esté
• Mi Xcode puede tronar en cualquier momento.
Tengan un poco de paciencia si esto ocurre.

9. Lo básico

10. Variables
var languageName: String = "Swift"
Reservada
Nombre
String
Tipo

11. Variable NO MUTABLE
let languageName: String = "Swift"
AKA Constante
Variables que no cambian después de crearse.
Ahorramos memória

12. Declaración : Optionals
No existe en C o en Objective-C
Es básicamente y en pocas palabras permitir
variables poder ser nil o no permitirles.
var serverResponseCode: Int? = 404
serverResponseCode = nil
var surveyAnswer: String? // automáticamente nil

13. Unwarping
let possibleString: String? = “string." // nil o string
println(possibleString!) // para verificar que no sea nil
let assumedString: String! = “implicito" // siempre existe
println(assumedString) // no se necesita

14. Pueden ser de mas tipos
¿Es enserio? tanto para casi volver a escribir mucho código

15. Solo bromeaba…
Tipado dinámico!

16. Lenguaje moderno

17. Strings
let i_am_a_string = “Soy un String"
let i_am_a_string2 = ‘Soy un String’

18. for caracter in “mejorando.la" {
println(caracter)
}
m
e
j
o
r
a
n
d
…

19. 🐭
🐭
🐭
🐭
for caracter in “🐭🐭🐭🐭" {
println(caracter)
}

20. Concatenar y Uso

21. Interpolación

22. Mutabilidad
var variableString = "Hola"
variableString += " como estan"
let constantString = "Hola"
constantString += “como estan"

23. Arreglos
var nombres = ["Leonidas", "Harvey", "Cvander", "Freddier"]
var nombres = ["Anna", "Alex", "Brian", "Jack", true]
var nombres : String []= ["Leonidas", "Harvey", "Cvander",
"Freddier"]
nombres.append("Ajamaica") nombres += "Vaca"

24. var nombre = nombres[0]
nombres[4...6] = ["Cambio", “Nuevo"] // sustituye del 4 al 6
nombres.insert("Ricardo", atIndex: 0)
let ricky = nombres.removeAtIndex(0)
for item in nombres {
println(item)
}

25. Mágia
var threeDoubles = [Double](count: 3, repeatedValue: 0.0)
!
// threeDoubles es tipo [Double], donde tiene [0.0, 0.0, 0.0]
var anotherThree= [Double](count: 3, repeatedValue: 2.5)
// [2.5, 2.5, 2.5]

26. Diccionarios
var miscursos = ["html": 6, "python": 0, "ios": 4]
miscursos["html"] = "7"
for (curso, veces) in miscursos {
println("(curso): (veces)")
}

27. Mágia
if let oldValue = miscursos.updateValue(8, forKey: "HTML")
{
println(“Viejo valor (oldValue).")
}
for skey in miscursos.keys {
println("keys: (skey)")
}

28. IF

29. Switch
Ejemplo numeros

30. Ciclos
while !cansado {
correr()
}
!
for var doctor = 1; doctor <= 13; ++doctor {
exterminate(doctor)
}

31. …
for index in 1...5 {
println("(index) multiplica (index * 5)")
}
var a = 1
var base = 5
// para no tener index
for _ in 1...5 {
a *= base
}

33. Funciones

34. Funciones
func diHola(nombre: String) -> String {
let saludo = "Hola, " + nombre + "!"
return saludo
}
println(diHola("Ana"))
func diHola2(nombre: String) -> String {
return "Hola, " + nombre + "!"
}

35. Multiples datos
func rangoDe(inicio: Int, fin: Int) -> Int {
return fin - inicio
}
println(rango(1, 10))

36. Sin return
func bye(nombre: String) {
println("bye, (nombre)!")
}

37. Varios return

38. Defaults y “títulos de
parametros”
func join(string s1: String, toString s2: String,
withJoiner joiner: String = " ") -> String {
return s1 + joiner + s2
}
join(string: "hello", toString: "world", withJoiner: "-")
join(string: "hello", toString: "world")

39. Paso por valor
func intercambia(inout a: Int, inout b: Int) {
let tempA = a
a = b
b = tempA
}
var a = 3
var b = 107
intercambia(&someInt, &anotherInt)
println(“Cambio (someInt), y tambien (anotherInt)")

40. Funciones “Funcionales”
func sumar(a: Int, b: Int) -> Int {
return a + b
}
func multiplicar(a: Int, b: Int) -> Int {
return a * b
}
!
var tempfunc: (Int, Int) -> Int = sumar
!
println("Result: (mathFunction(2, 3))")
tempfunc = multiplicar
println("Result: (mathFunction(2, 3))")

41. Funciones como parámetro
de otras
func imprimir(tempfunc: (Int, Int) -> Int, a: Int, b: Int) {
println("Resultado: (tempfunc(a, b))")
}
imprimir(sumar, 3, 5)

42. Closures
Los closures, en castellano cierres o clausuras, son una
potente característica de JavaScript que también podemos
encontrar en otros lenguajes como C#, Objective-C, Eiffel y
otros.
!
Es la manera en como una función dentro de otra función
contenedora puede hacer referencia a las variables
después de que la función contenedora ha terminado de
ejecutarse.
Recuerda el curso Frontend de Mejorando.la

43. func incrementar(incrementeLaCantidad cantidad: Int) -> () -> Int {
var corrio = 0
!
func incrementador() -> Int {
corrio += cantidad
return corrio
}
!
return incrementador
}
!
let incrementa10 = incrementar(forIncrement: 10)
let incrementa20 = incrementar(forIncrement: 20)
!
incrementa10()
incrementa20()

44. var numbers = [20, 19, 7, 12]
!
numbers.map({
(number: Int) -> Int in
if n % 2 == 0 {
return n
}
else {
return 0
}
})
!
La function map ejecuta el
closure para cada elemento del
arrego.

45. var reversa = sorted(nombres, { (s1: Int, s2: Int) -> Bool in
return s1 > s2
})
func reversaFuncAuc(s1: Int, s2: Int) -> Bool {
return s1 > s2
}
var reversa = sorted(nombres, reversaFuncAuc)
La función sorted
ordena los números
dada una función
var reversed = sorted(nombres, { s1, s2 in return s1 > s2 } )
Newbie
Común
Pro
reversed = sorted(nombres, { $0 > $1 }) Swift

46. Clases

47. Estructura básica
class Vehiculo {!
! // propiedades!
// metodos!
// inicializadores!
}

48. .h
No mas archivos

49. Herencia
class Vehiculo {
!
}
!
class Bicicleta: Vehiculo {
!
}

50. Propiedades guardadas
class Vehiculo {
var numero_ruedas = 0
}

51. Propiedades dinámicas
class Vehiculo {
var numero_ruedas = 0
var descripcion: String {
get {
return "(numero_ruedas) ruedas"
} }
}

52. Más fácil
class Vehiculo {
var numero_ruedas = 0
var descripcion: String {
return "(numero_ruedas) ruedas"
}
}

53. Inicializar
let unvehiculo = Vehiculo()
Aquí no hay razón para ser un var. Lo que cambia es el
contenido del objeto no el objeto como tal

54. Acceder a propiedades
let unvehiculo = Vehiculo()
println(unvehiculo.descripcion)
No lleva () por que no es una función. Por eso vimos
closures. Es como un @property de python
unvehiculo.ruedas = 4

55. Inicialización
class Bicicleta: Vehiculo {
init() {
super.init()
ruedas = 2
} }
let bici = Bicicleta()

56. Override
class Auto: Vehiculo {
var velocidad = 0.0
init() {
super.init()
ruedas = 4
}
override var descripcion: String {
return super.description + ", (speed) km/h"
}
}

57. Metodos
class Contador {
var total = 0
func incrementa(cantidad: Int) {
total += cantidad
}
func resetea_a_nuevo(nuevo: Int) {
self.total = nuevo
}
}

58. Structs

59. Structs

60. Playground
• Colors
• Strings (plain and attributed) Images
• Views
• Arrays and dictionaries Points, rects, sizes
• Bézier paths
• URLs
• Classes and structs

61. Optional Chaining

63. Automatic Reference
Counting
Uno de los cambios más abrumadores de iOS ha sido la
inclusión de ARC (Automatic Reference Counting), lo cual facilita
al desarrollador la gestión de memoria, uno de los puntos mas
conflictivos del desarrollo iOS.
!
Esto erá el cancer de IOS hasta la llegada de ARC.

64. Un concepto que deberemos tener siempre en mente es
el tipo de relación que queremos establecer entre el
puntero y los objetos a los que apunta. Ésta podrá ser de
dos tipos dependiendo de su naturaleza:
!
Strong: un puntero de este tipo, implica que nuestra
variable será la dueña del objeto al que apunta el
puntero, y por tanto no se liberará el mismo mientras el
puntero siga activo.
!
Weak: es un puntero que no implica que nuestra variable
sea dueña del objeto apuntado. De este modo, si por
cualquier motivo el objeto apuntado fuera liberado,
nuestro puntero pasaría ser automáticamente NIL (esto
evita que se produzcan errores por apuntar a direcciones
de memoria inexistentes).

65. weakstrong

66. Otras cosas que hay…
Tarea
• Observers
• Enums en Structs
• Extensions
• Optional Return Types

67. Consultar
https://developer.apple.com/library/prerelease/mac/
documentation/Swift/Conceptual/
Swift_Programming_Language/TheBasics.html#//apple_ref/
doc/uid/TP40014097-CH5-XID_443

68. Día 2

69. Xcode

71. Live Rendering

72. Tour

73. AutoLayout (nuevo)

79. UITableViewController
La vista de tabla (UITableView) es el componente central en
muchas aplicaciones. Es un elemento con muchas opciones, es
importante que aprendamos a utilizarlas correctamente.
!
Las clases que intervienen a la hora de representar una tabla son:
UITableView : La tabla en sí
UITableViewCell : Cada una de las celdas de una tabla
!
Para empezar a trabajar con las tablas, vamos a crear un nuevo
controlador que llamaremos CTControllerView y haremos que sea
una subclase de UITableViewController.

80. UITableview
• Viendo la implementación que nos creó por defecto Xcode, vemos que hay
muchos métodos propios de un controlador de tabla.
• Estos métodos en realidad son de los protocolosUITableViewDelegate y
UITableViewDataSource. El delegate tiene información de cómo se tiene que
comportar la tabla, por ejemplo el tamaño de las celdas, el método que se ejecuta
cuando se selecciona una celda, etc. Por otro lado, el datasource tiene
información del contenido que tiene que mostrar la tabla, por ejemplo el número
de celdas, el número de secciones, el contenido de las celdas, etc. Revisa la
documentación de las dos clases para que veas los métodos que tienen.
• Observando la documentación vemos que los únicos métodos que son requeridos
son:
• tableView:cellForRowAtIndexPath : Devuelve la celda configurada.
• tableView:numberOfRowsInSection : Devuelve el número de celdas que hay en
cada sección. Por defecto hay una única sección.

81. Cell Patrón
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:
(NSIndexPath *)indexPath {
static NSString *CellIdentifier = @"Cell";
UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:CellIdentifier];
if(cell == nil){
cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault
reuseIdentifier:CellIdentifier];
}
Object *objeto = [arreglo.data objectAtIndex: indexPath.row];
cell.textLabel.text = objeto.nombre;
return cell;
}

82. Cocoapods y Parse