Documente Academic
Documente Profesional
Documente Cultură
ndice .............................................................................................................................................................2
Bienvenida ...................................................................................................................................................3
Objective-C o Swift? Qu lenguaje aprender para programar en iOS ................................4
Swift vs Objective-C: 5 preguntas indispensables para decidirse por un lenguaje ..........9
Introduccin a la sintaxis de Swift y Objective-C ....................................................................... 13
Conceptos fundamentales de Swift ................................................................................................ 24
9 ideas interesantes de Swift sacadas de otros lenguajes ...................................................... 30
Swift y los nulos...................................................................................................................................... 43
Estructura de una aplicacin iOS ..................................................................................................... 49
El ciclo de vida de una aplicacin iOS ............................................................................................ 54
Y ahora qu?.......................................................................................................................................... 56
facebook.com/campusMVP
twitter.com/campusMVP
youtube.com/campusMVPes
Bienvenida
Te damos la bienvenida a este eBook sobre desarrollo para iOS
Este documento est dirigido a programadores que tienen inters en programar
para dispositivos mviles de Apple (iPhone y iPad), y que quieren tener un primer
contacto con los dos lenguajes disponibles para esta plataforma: Objective-C y
Swift.
As, no se trata de un eBook apropiado para gente que nunca ha programado.
Aunque todo lo explicado es bsico, para entenderlo es necesario disponer de unos
conocimientos mnimos de programacin.
No se trata tampoco de un documento de iniciacin a estos lenguajes, sino que
con este eBook perseguimos bsicamente tres objetivos:
Ayudarte a decidirte por uno u otro lenguaje en funcin de tus necesidades
Que tengas un primer contacto con ellos para "perderles el miedo"
Que conozcas algunos conceptos bsicos de ambos para poder empezar con
mayor facilidad
Esperamos aportar nuestro granito de arena en tu camino hacia el aprendizaje :-)
Como dice el viejo chiste: "Cmo te comeras un elefante?... Pues trocito a trocito,
claro. "
facebook.com/campusMVP
twitter.com/campusMVP
youtube.com/campusMVPes
Objective-C y Swift son el pegamento que une todo lo que ofrece Cocoa
Touch. Es decir, Cocoa Touch es la base que utilizan tanto Objective-C
como Swift.
Por ello, aprender un lenguaje o el otro realmente es una cuestin casi "esttica" y de
preferencia, puesto que lo verdaderamente importante es aprender lo que hay
debajo de ambos.
Pros y contras
Dado que Swift es el nuevo y moderno lenguaje que est impulsando Apple, merece
la pena aprender tambin Objective-C o vamos directamente a por Swift?
Sin duda Swift es el futuro y adems es un lenguaje moderno que ofrece muchas
ventajas frente a Objective-C:
Cdigo ms conciso, claro y limpio que facilita la escritura y la comprensin
Ofrece tipado fuerte de datos, inferencia de tipos, sobrecarga de operadores...
Elimina los punteros, controla el desbordamiento de variables
Gestin automtica de la memoria
Genricos
Estructuras con mtodos, extensiones y protocolos
Facilita mucho la depuracin
Facilita el uso de patrones de programacin funcional
Etc...
Por el contrario Objective-C es mucho menos transigente con los errores, tiene una
sintaxis complicada y adems ofrece ciertos conceptos que resultan complejos para
programadores que vienen de otros lenguajes, como:
Protocolos
Categoras y selectores (aunque estos ltimos se usan en Swift tambin tienen
mucha ms friccin)
Dispatch dinmico
First responders
Bloques
Etc...
Ante este panorama, claramente, parece que lo inteligente sera aprender
directamente Swift no?
facebook.com/campusMVP
twitter.com/campusMVP
youtube.com/campusMVPes
La realidad es que, aunque Swift resulte ms fcil para un programador que viene de
otras plataformas, Objective-C se puede aprender en cuestin de unas pocas horas
tambin, aunque parezca mentira.
Dado que ambos deben utilizar Cocoa Touch por debajo y esta API est escrita en su
totalidad con Objective-C, aunque programes en Swift no te puedes librar de conocer
igualmente los conceptos avanzados propios del otro lenguaje, como los principios
de orientacin a objetos de Objective-C, punteros, protocolos, delegados, montones,
pilas.... simplemente para poder usar la base. Es decir, aunque programes en Swift
debes jugar con las reglas de Objective-C. Vamos, es como aquel famoso anuncio de
los 90 del juego Scattergories ;-) .
facebook.com/campusMVP
twitter.com/campusMVP
youtube.com/campusMVPes
En cualquier caso, y sea cual sea tu circunstancia o la idea que tengas, aprender
Swift es indispensable, pero aprender Objective-C es ms que recomendable
porque tarde o temprano tendrs que pelearte con l, puesto que existen miles de
bibliotecas y cdigo abierto que solo existe en este lenguaje. De hecho la propia base
del desarrollo para iOS y Mac, Cocoa, est escrito en Objective-C, y es til conocer
algunos de sus conceptos para entender mejor su funcionamiento cuando programes
en Swift.
En unos cuantos aos s que es probable que, finalmente, puedas prescindir de
Objective-C y usar solamente Swift. Hoy por hoy todava es complicado.
facebook.com/campusMVP
twitter.com/campusMVP
youtube.com/campusMVPes
10
11
Pero Objective-C tiene algunas cosas especficas que no hay en Swift, como la
potente capacidad de reflexin que tiene este lenguaje, la posibilidad de enviar
mensajes a nil, enlazar y embeber cdigo escrito en C, declarar y exponer estructuras
C...
Aunque es cierto que algunas de estas cuestiones son algo esotricas y no tendrn
importancia en el da a da, disponer de un conjunto de herramientas ms amplio
siempre es recomendable.
Es interesante consultar la gua de Apple para interoperatividad entre Swift y Cocoa y
Objective-C.
facebook.com/campusMVP
twitter.com/campusMVP
youtube.com/campusMVPes
12
Constantes y Variables
Para declarar una variable en Swift usaremos la palabra reservada var :
var numero = 1
En Objective-C:
int numero = 1;
13
Las diferencias principales son que, en Swift, no hay que poner el punto y coma al
final ni hay que definir el tipo de variable de que se trata. Esto se debe a que Swift
permite la inferencia de tipos y es capaz de entender que la variable es un nmero
debido a su valor inicial.
Aunque si quieres, puedes definir tambin el tipo de variable explcitamente:
Aqu la declaracin en Swift queda muy limpia y se parece bastante a lo que sera,
por ejemplo, en JavaScript. Pero, cmo se hara en Objective-C?:
NSString*lenguaje=@"Swift";
Con Swift no hay necesidad de usar punteros de memoria (*) o de ponerle una @ de
prefijo al valor.
Las constantes en Swift se pueden declarar usando la palabra let :
facebook.com/campusMVP
twitter.com/campusMVP
youtube.com/campusMVPes
14
NSString*const lenguaje=@"Swift";
Arrays
En Swift los arrays y diccionarios se crean usando corchetes [] y se accede a sus
elementos escribiendo su posicin dentro de la matriz.
En Objective-C:
15
arr += ["tercero"]
facebook.com/campusMVP
twitter.com/campusMVP
youtube.com/campusMVPes
16
o la funcin append:
arr.append("cuarto")
Bucles
Hasta ahora hemos visto cmo crear elementos. Ahora veamos cmo trabajar con
bucles a travs de ellos.
//haz algo
}
17
Hasta aqu ambos lenguajes se parecen mucho, pero es que, adems con Swift
puedes usar la variante for in para obtener el mismo resultado:
for i in 1...10 {
//haz algo
}
Tanto Swift como Objective-C disponen de bucles while y repeat con sintaxis casi
idnticas variando solamente la declaracin de las variables como ya sabemos:
while n < 10 {
//haz algo
n++
}
Lo que est escrito despus de la declaracin while debe poder evaluarse a un valor
verdadero o falso, y el cdigo se ejecutar mientras esta condicin sea true . En el
ejemplo el bucle dar 10 vueltas ya que le sumamos 1 a la variable n al final de cada
vuelta.
facebook.com/campusMVP
twitter.com/campusMVP
youtube.com/campusMVPes
18
var n = 0
repeat {
//haz algo
n++
} while n<10
Condicionales
Mientras los bucles se encargan de tareas repetitivas, las sentencias if y switch se
encargan de controlar el flujo del programa, tomando decisiones en funcin de
ciertas condiciones.
if
if ciudad == "MAD" {
print("Madrid")
}
19
if (ciudad == "MAD") {
print("Madrid")
}
Que es vlido en los dos lenguajes. En Swift es opcional, as que elige la opcin que
prefieras, aunque por regla general los programadores experimentados suelen usar la
segunda opcin, ms coherente con la sintaxis de otros lenguajes.
Tras la condicin principal con if puede aparecer una opcin a ejecutar en caso de
que no se cumpla la condicin, usando o bien else if, que abre una nueva rama
condicional, o bien un simple else que abre solo la rama alternativa:
if ciudad == "MAD" {
print("Madrid")
} else if ciudad == "BCN" {
print("Barcelona")
} else {
print("Zaragoza")
}
Switch
facebook.com/campusMVP
twitter.com/campusMVP
youtube.com/campusMVPes
20
switch ciudad {
case "MAD":
print("Madrid")
case "BCN":
print("Barcelona")
default: print("Zaragoza")
}
switch (valor) {
case 0:
print("Madrid");
break;
case 1:
print("Barcelona");
break;
default:
print("Zaragoza");
break;
}
21
En Swift, sin embargo, no hace falta una sentencia break ya que no salta al siguiente
case de manera implcita. Esto significa que, una vez que un caso se evala como
true y se ejecuta, el siguiente caso no se evaluar.
Pero an as es necesario especificar una accin por defecto, para lo cual se usa la
palabra clave default en ambos casos. Esta rama ser la que se ejecutar si ninguna
de los casos anteriores coincide.
En Swift la sentencia case puede contener mltiples valores separados por comas o
espacios, y podemos usar NSString para la condicin, cosa que no es posible en
Objective-C (por eso en nuestro ejemplo hemos usado enteros, que son junto con los
valores enumerados, los nicos tipos admitidos por este lenguaje).
Funciones
Para declarar una funcin en Swift se usa la palabra clave func:
func miNombre() {
print("Juan")
}
Como en casi cualquier otro lenguaje, podemos pasarle parmetros dentro de los
parntesis especificando nombre y tipo de variable, separndolos por comas si hay
ms de uno:
Para declarar funciones que devuelvan resultados aadiremos un -> despus de los
parmetros, indicando a continuacin el tipo de dato que va a devolver.
facebook.com/campusMVP
twitter.com/campusMVP
youtube.com/campusMVPes
22
que tiene una sintaxis mucho ms complicada dentro, pero que, en lo que es la
declaracin de la funcin, es ms o menos igual de sencillo.
23
Enumeraciones
Las enumeraciones son uno de los aadidos interesantes de Swift frente a ObjectiveC. Bsicamente una enumeracin (enum) permite declarar un conjunto de valores
bajo un nombre identificativo. Las enumeraciones de Swift pueden tener mtodos
asociados y conformar protocolos (ms sobre esto luego).
Se parecen mucho ms a las enumeraciones de Java o a las enum class de C++ 11
que a las enumeraciones clsicas de C++ o de C#.
Clases
Las clases constituyen uno de los pilares fundamentales de Swift. Al igual que
Objective-C, Swift posee herencia simple, es decir, una clase puede heredar tan solo
de otra clase, no de varias a la vez. Se pueden formar jerarquas de clases todo lo
complejas que sea necesario, pero donde cada clase tenga una sola clase base.
facebook.com/campusMVP
twitter.com/campusMVP
youtube.com/campusMVPes
24
Referencias
Swift no tiene punteros, usa referencias en su lugar. Eso significa que no debemos
explicitar el tipo puntero para tener una variable que contenga un objeto.
As, si en Objective-C para declarar una variable que contenga un objeto de un tipo
MyClass, debemos declarar la variable como MyClass* (el asterisco significa puntero
a, por lo que MyClass* se lee como puntero a un objeto MyClass), en Swift basta
con declararla de tipo MyClass.
Esto hace que para el desarrollador el trabajo con objetos sea idntico al trabajo con
tipos simples: en Objective-C una variable de tipo int sola ser simplemente int y no
int* (aunque esta segunda es vlida en segn que contextos). Esto aade una
complejidad que en Swift desaparece.
Swift define el valor nil como "ausencia de valor". En Swift por defecto las
referencias son no nulables, es decir no pueden contener el valor nil. Para que una
referencia sea nulable (y por lo tanto contener el valor nil para indicar que no
contiene ningn objeto) debe declararse explcitamente como tal aadiendo ? al final
del tipo:
25
Si la clase MyClass tiene una propiedad name, para acceder a ella usaramos:
var x = f.name
// Si f es una referencia NO nulable(MyClass)
var x = f?.name
Para convertir una referencia nulable en una no nulable (y por lo tanto "extraer" el
objeto que contenga dicha referencia no nulable) se usa el operador ! (admiracin):
var x = f!
var n = f!.name
// Si fa vale nil dar un error de ejecucin. En caso
contrario n ser el valor de la propiedad name del objeto
apuntado por f
facebook.com/campusMVP
twitter.com/campusMVP
youtube.com/campusMVPes
26
Protocolos
Un protocolo es el equivalente en Swift a las interfaces de C# y Java. Es decir, un
protocolo define un conjunto de mtodos que luego una clase debe implementar.
Cuando una clase implementa los mtodos de un protocolo se dice que "conforma
dicho protocolo".
Un aspecto a tener presente de los protocolos es que stos pueden definir mtodos
opcionales, es decir, mtodos que pueden, aunque no tienen por qu, ser
implementados por las clases que conformen dichos protocolos.
Se pueden declarar referencias a protocolos y usar parmetros y valores de retorno
de tipo protocolo.
Genricos
Los genricos son una de las novedades ms destacadas de Swift respecto a
Objective-C.
Si conoces este concepto de C# o Java, o bien ests familiarizado con las templates
de C++ no te costar mucho entenderlo (aunque los genricos de Swift tienen
mucho ms parecidos con los de C# o Java que con las templates).
Se llama genricos a la posibilidad de pasar como un parmetro un tipo en lugar
de un valor. Los genricos permiten una mayor reutilizacin de cdigo al poder
reaprovechar un mismo cdigo (una clase o un mtodo) para que trabaje con varios
tipos de datos distintos.
Inferencia de tipos
Swift es un lenguaje con tipado esttico, es decir, las variables tienen un tipo
establecido en tiempo de compilacin, al contrario que en otros lenguajes dinmicos
como JavaScript por ejemplo, donde una variable puede contener un valor de un
determinado tipo y al instante siguiente albergar datos de un tipo completamente
distinto.
27
var message
facebook.com/campusMVP
twitter.com/campusMVP
youtube.com/campusMVPes
28
29
1. Operador de rango
El operador de rango (...) permite definir directamente un rango de valores. Los
rangos son un tipo de datos vlido por lo que pueden ser asignados a variables:
facebook.com/campusMVP
twitter.com/campusMVP
youtube.com/campusMVPes
30
var from = 2
var to = 12
var range = from...to
var start = 10
var start = 10;
Eso s, el punto y coma sigue siendo obligatorio para separar sentencias en una
misma lnea:
31
3. Tuplas
Las tuplas se incorporan como tipo nativo del lenguaje:
Las tuplas se pueden pasar como parmetros o ser devueltos por una funcin:
Las tuplas pueden tener parmetros nombrados lo que reduce mucho la necesidad
de crear clases que se usan una sola vez:
facebook.com/campusMVP
twitter.com/campusMVP
youtube.com/campusMVPes
32
4. Enumeraciones
Muchos lenguajes soportan enumeraciones, pero pocos las tienen tan potentes como
las de Swift. As las enumeraciones pueden tener mtodos e implementar
interfaces (protocolos en la jerga de Swift). La declaracin de enumeraciones es muy
sencilla:
enum Features {
33
switch (self) {
case .Basic:
return "Basic features only"
case .Advanced:
println(descriptable.Description())
facebook.com/campusMVP
twitter.com/campusMVP
youtube.com/campusMVPes
34
5. Sobrecarga de operadores
La sobrecarga de operadores es la posibilidad de utilizar los operadores del lenguaje
para nuestros tipos. As en Swift es posible tener, por ejemplo, una clase Complex y
definir el operador de suma (+) sobre elementos de dicha clase.
Supongamos la siguiente clase Complex:
class Complex {
var real : Double = 0.0
var imaginary : Double = 0.0
init() {}
init(r:Double, i:Double) {
self.real = r
self.imaginary = i
}
}
35
operator infix +- {}
Con eso reservamos este token (+-) para poder ser usado como operador "infijo" (es
decir "en medio de dos") para cualquier tipo en el que est definido (recuerda, eso s,
que se definen siempre como funciones globales).
Una vez el operador est reservado podemos definirlo:
facebook.com/campusMVP
twitter.com/campusMVP
youtube.com/campusMVPes
36
Y values ser un rango que comprender los valores desde el 3 hasta el 7 (ambos
inclusive).
6. Genricos
Genricos es la posibilidad de definir un parmetro que no toma un valor sino un
tipo. Es una caracterstica que se puede encontrar en Java y en C#. Por su parte C++
tiene algo que conceptualmente es parecido (templates) pero que es mucho ms
potente (y complejo) que los genricos. Swift se alinea ms con Java y C#:
class Stack<T> {
var items = T[]()
func push(item: T) {
items.append(item)
}
func pop() -> T {
return items.removeLast()
}
}
37
La clase Stack puede contener cualquier tipo de datos, as podemos tener una pila de
cadenas:
En este caso el parmetro genrico T tan solo puede tomar un valor de un tipo que
derive de XX o conforme el protocolo XX (dependiendo de si XX es el nombre de una
clase o de un protocolo).
facebook.com/campusMVP
twitter.com/campusMVP
youtube.com/campusMVPes
38
8. Extensiones
Las extensiones permiten aadir mtodos y propiedades a una clase ya existente
sin necesidad de modificar el cdigo fuente de dicha clase:
39
class Foo {
var value = 0
func inc() {
self.value++
}
}
extension Foo {
func dec() {
self.value-}
}
var foo = Foo()
foo.inc()
foo.dec()
En este caso la extensin define un mtodo adicional (dec) que luego podemos
llamar como si fuese un mtodo propio de la clase. Dentro de los mtodos de una
extensin podemos usar self para referirnos al objeto extendido (al igual que en los
mtodos propios de la clase).
facebook.com/campusMVP
twitter.com/campusMVP
youtube.com/campusMVPes
40
class Wrapper {
var value = 0
}
func updateWrapper (wrapperToUpdate: Wrapper) {
wrapperToUpdate.value = wrapperToUpdate.value + 10
}
var intValue = Wrapper()
intValue.value = 10
updateWrapper(intValue)
println(intValue.value)
41
Eso es debido a que la referencia se pasa por valor (es decir se copia la referencia,
no su contenido que quede claro). Por norma general asignar una referencia
recibida como parmetro a un nuevo objeto no suele ser necesario, pero en segn
que casos puede ser interesante. Para esos casos Swift soporta pasar una referencia
por referencia utilizando la palabra clave inout:
println(intValue.value)
facebook.com/campusMVP
twitter.com/campusMVP
youtube.com/campusMVPes
42
class Ufo {
init() {}
var name
= ""
Podemos declarar una referencia que contenga un objeto de tipo Ufo de la siguiente
manera:
var u =
Ufo()
43
Pero si luego intentamos asignar el valor nil a dicha referencia se obtendr un error
(Type does not conform to protocol NilLiteralConvertible).
Podemos declarar la variable sin inicializarla, pero Swift nos obligar a asignarle un
valor antes de poder usarla. Supongamos una funcin UfoName que devuelva el
nombre de un objeto Ufo:
var u:Ufo
UfoName(u)
Referencias opcionales
Por supuesto a veces nos interesa que una referencia pueda tener el valor de nil.
Para ello, Swift nos ofrece las referencias opcionales:
facebook.com/campusMVP
twitter.com/campusMVP
youtube.com/campusMVPes
44
o el valor nil. De hecho, esta referencia se inicializa, por defecto, a nil. Si ahora
llamamos a la funcin UfoName pasndole la referencia optionalUfo (cuyo valor es
nil) obtendremos un error (Value of optional type not unwrapped):
Este error es debido a que UfoName espera una referencia de tipo Ufo y no una de
tipo Ufo? Para "extraer" el valor Ufo que hay dentro de una referencia Ufo? debemos
usar el operador postfijo !
UfoName(optionalUfo!)
Por supuesto si la referencia opcional vale nil como es el caso, la funcin llamada
(en este caso UfoName) recibir un nil incluso aunque ella declaraba que esperaba
una referencia de tipo Ufo (que a priori no puede tener el valor nil).
En este caso nos encontraremos intentando acceder a una referencia nula:
Pero Swift nos ofrece todava ms herramientas para ayudarnos a lidiar con posibles
referencias nulas. El operador ? es otra de ellas. Dicho operador nos permite acceder
al valor de una propiedad opcional solo si dicha referencia contiene un objeto. En
caso contrario devolver nil. Solo podemos usar este operador en referencias
opcionales.
As pues podramos reescribir la funcin UfoName como sigue:
45
return u?.name
}
Podemos observar que ahora declaramos que la funcin acepta una referencia
opcional a Ufo y devuelve una referencia opcional a String (es decir puede devolver
nil). Ahora ese cdigo es vlido y no produce error alguno:
var u = Ufo()
u.name = "Zynga"
UfoName(u)
Protocolo NilLiteralConvertible
Si una clase implementa dicho protocolo puedes definir cmo se inicializa una
referencia no opcional de dicha clase cuando se le asigna el valor nil. Es decir,
eso viene a ser como "redefinir el valor de nil".
facebook.com/campusMVP
twitter.com/campusMVP
youtube.com/campusMVPes
46
= ""
self()
Vemos pues que, aunque tenemos una referencia que no es opcional, le podemos
asignar el valor nil debido a que la clase conforma el protocolo
NilLiteralConvertible.
47
Pero debemos tener presente que a pesar de que le asignamos nil, la referencia
termina obteniendo un objeto (el objeto devuelto por el mtodo
convertFromNilLiteral).
Por supuesto si usamos una referencia opcional, entonces nil adquiere su
significado original:
Espero que esto te ayude a comprender un poco ms cmo funcionan las referencias
y los valores nulos en Swift.
facebook.com/campusMVP
twitter.com/campusMVP
youtube.com/campusMVPes
48
Cocoa Touch es una adaptacin de Cocoa (framework que se usa para el desarrollo
de aplicaciones MacOSX) para interfaces tctiles.
49
Las clases en Cocoa Touch estn organizadas en varios grupos que se diferencian por
su prefijo (dos letras maysculas al principio de la clase). Los prefijos ms comunes
son:
NS: Para las clases que forman parte del Foundation Kit, que contiene todas
aquellas clases de uso comn y las clases base ms importantes. P. ej. la clase
base de todas las clases se llama NSObject. Por ejemplo, un par de clases que
tienen este prefijo son NSString y NSDictionary.
UI: Para las clases que forman parte del UIKit, que contiene todas aquellas
clases para crear interfaces grficas de usuario.
nombres. Es por ello que se suele usar siempre un prefijo que se aade al
nombre de las clases. Los prefijos de dos letras maysculas estn
reservados para Apple y no debes usarlos al definir tus clases.
El modelo de desarrollo para iOS se basa en el patrn MVC (Modelo - Vista Controlador). Como suele ocurrir en estos casos, no hay una definicin formal de lo
que es la M (se trata del modelo, los datos de tu aplicacin) pero tanto la V como la C
s que estn claramente delimitados.
Lenguaje Swift
Como sabemos, Swift viene a ser el "lavado de cara" que se debera efectuar a
Objective-C pero, que por razones de compatibilidad no es posible realizar. A pesar
de que Apple ha ido modernizando y remodelando Objective-C con el paso del
tiempo, el propio origen del lenguaje y su filosofa hacen que llegados a cierto punto
sea muy difcil seguir modernizndolo: su mezcla de sintaxis (y conceptos) entre C y
Smalltalk, el uso de punteros y el modelo de gestin de memoria, hacen que
Objective-C sea un lenguaje poco amigable. Swift viene a solucionar todo eso.
facebook.com/campusMVP
twitter.com/campusMVP
youtube.com/campusMVPes
50
Pero Swift mantiene una compatibilidad casi total con las APIs existentes. Al
desarrollar en Swift no se desarrollar contra una nueva versin de Cocoa Touch sino
que Swift define los "enlaces" (bindings) que tiene con Objective-C, es decir: es
posible llamar a cualquier API desarrollada en Objective-C usando Swift. Existen un
conjunto de conversiones y convenciones que deben tenerse en cuenta y poco ms.
De hecho es posible mezclar Objective-C y Swift dentro del mismo proyecto, con
lo que viejo cdigo Objective-C que exista puede reaprovecharse en proyectos
nuevos hechos con Swift.
Recuerda: las APIs que se usan para desarrollar en Swift son las mismas que se
usan para hacerlo con Objective-C. Solo hay que tener presente algunas
convenciones.
Vistas
Una vista en iOS contiene el aspecto grfico. Por aspecto grfico nos estamos
refiriendo a los controles (botones, textos, etc.), a su disposicin y a sus atributos de
presentacin (colores, fuentes, etc.).
Una cuestin importante relativa a las vistas es que todo en iOS es una vista. No
solo las pantallas de tu aplicacin, sino tambin los controles que tengas en ella. Un
botn es una vista, al igual que tu pantalla o que el contenido que muestres en
una fila de una tabla. Todos esos elementos terminan derivando al final de UIView
que es la clase base para todas las vistas.
Para definir las vistas de tu aplicacin se usa un storyboard que contiene no solo
las vistas de tu aplicacin sino tambin las transiciones (o navegaciones) entre ellas.
Por supuesto el IDE de Apple, XCode, ofrece un editor de vistas y de storyboards
completamente grfico.
Storyboards
Como se ha comentado los storyboards definen que vistas hay en tu aplicacin,
pero tambin las transiciones entre ellas.
Las vistas se denominan Escenas (Scenes) y las transiciones Segues.
Mediante el editor grfico integrado en XCode podrs aadir vistas al storyboard y
crear transiciones nuevas entre esas vistas.
51
Una ventaja de los storyboards es que al gestionar las transiciones de forma grfica se
pueden escribir prototipos de aplicaciones con muy poco cdigo.
Outlets y Actions
Cuando el usuario interacciona con tu aplicacin y hace algo como pulsar un botn,
se genera un evento que debe ser capturado en el controlador. Se denomina action
al mtodo del controlador que captura un evento lanzado por la vista (o
cualquier control o "subvista" que est en su interior). As, si el usuario hace clic en un
botn habr una action en el controlador que se encargar de ejecutar algo cuando
suceda este clic.
El controlador por norma general requiere tener acceso a los elementos (llmalos
controles o "subvistas" si quieres) que estn dentro de la vista. Por ejemplo, si un
controlador debe modificar el texto mostrado por una etiqueta, debe poder acceder
a dicha etiqueta para poder modificar sus propiedades. Esto se realiza a travs de un
Outlet. As pues, un controlador suele ser una combinacin de actions que se
encargan de gestionar los eventos e interaccionan con los otros controles de la vista
a travs de los outlets.
facebook.com/campusMVP
twitter.com/campusMVP
youtube.com/campusMVPes
52
53
facebook.com/campusMVP
twitter.com/campusMVP
youtube.com/campusMVPes
54
pantalla as que solo habr una aplicacin en el estado de foreground cada vez.
El estado foreground se divide en dos sub-estados:
Active: La aplicacin se est mostrando y est recibiendo los eventos del
sistema operativo. Es decir, el usuario est interaccionando con la aplicacin.
Not active: La aplicacin se est mostrando pero no est recibiendo los
eventos del sistema operativo. Esto puede ocurrir cuando entra una llamada
telefnica o bien se activa la pantalla de bloqueo.
Background: Una aplicacin pasa a estar en el estado de background cuando
deja de ser la aplicacin que est en foreground, es decir, cuando el usuario
cambia a otra aplicacin. Eso no significa que la aplicacin deje de ejecutarse
(y pase a not running). Si la aplicacin tiene permisos para ejecutarse en
segundo plano podr seguir ejecutando cdigo aunque no sea la aplicacin
que el usuario est viendo.
Suspended: Una aplicacin pasa a este estado cuando est en background y
no ejecuta ningn cdigo. Se mantiene la memoria RAM de esta aplicacin,
pero no obtiene ningn ciclo de CPU. Es decir, la aplicacin est suspendida
pero no muerta. Una aplicacin en este estado puede ser terminada en
cualquier momento por el sistema operativo, as que antes de entrar en este
estado debemos guardar todos los datos necesarios por si acaso iOS decide
matar nuestra aplicacin (lo que ocurre cuando requiere liberar memoria
RAM).
Por supuesto iOS informar a tu aplicacin de cualquier cambio de estado y tu
cdigo deber responder adecuadamente. Por norma general iOS no es muy gentil:
cualquier cosa que hagas mal suele terminar con que el sistema operativo cierra
tu aplicacin sin contemplaciones.
55
Y ahora qu?
Enhorabuena! Has llegado al final del eBook. Esperamos que estos artculos te hayan
aclarado un poco qu te vas a encontrar si decides adentrarte a crear apps para iOS, te
resulten tiles y los pongas en prctica.
facebook.com/campusMVP
twitter.com/campusMVP
youtube.com/campusMVPes
56
57