Introducción a Swift, lenguaje de programación de iOS y OS X

Este tutorial de Swift, el nuevo lenguaje de programación de Apple para iOS y OS X, te dará la introducción básica a programar apps nativas móviles para iPhone, iPad y Macs.

Swift es un "reemplazo" a Objective-C. Un lenguaje poderoso, pero intimidante para muchos programadores novatos. Con Swift podrás crear apps para iOS y Mac OS X.

Swift será enseñado a fondo en el Curso de programación para iPhone, iPad y iOS de Mejorando.la.

Variables

Declarar una variable funciona muy similar a Actionscript

Código :

var freddier = 2501
otra = "ola ke ase"

No hay necesidad de punto y coma. El "var" también es opcional. El tipo de variable queda fijo una vez la declaras, igual que en Python. Aunque se puede ser específico

Código :

var freddier: Double = 100, cvander: Int = 50

Y con la coma puedes declarar varias variables al tiempo.

Las constantes se declaran con let

Código :

let cvander = "@cvander"

Y sólo pueden ser asignadas una vez, por eso son constantes. Aunque la asignación puede ser en tiempo de ejecución.

Las conversiones de tipo de variable funcionan muy similar a Python

Código :

var mensaje = "Freddie mide "
var altura = 1.7
var tweet = mensaje + String(altura)

Pero una forma más fácil de hacer conversión es usando paréntesis y backslash:

Código :

   var tweet = "Freddie mide \(altura)"

Se ve feo, pero seguro que con la práctica le tomarás amor.

Los arrays y diccionarios se crean con []

Código :

   var cursos = ["marketing", "diseño", "programación"]
   println(cursos[1])
   //diseño

Y los diccionarios tipo JSON funcionan igual:

Código :

   var fundadores = [
      "Freddie": "@freddier",
      "Christian": "@cvander",
   ]
   println(fundadores["Freddie"])
   //@freddier

Observa que puedes dejar la coma al final y nada malo pasa. No como el odioso Javascript cuando cometes ese error en JSON.

Arrancar un Array vacío es bien raro

Código :

   //Una matriz vacía de strings
   var matriz = String[]()
   //Un diccionario de strings y números, como JSON
   var json = Dictionary<String, Float>()

Condiciones

El if no necesita paréntesis

Código :

   if dinero_mensual > 29 
   {
      cursos_mejorandola += 1
   }
   else
   {
      mejor_empleo = 0
   }

Pero la comparación debe ser booleana. No puedes comparar cero con falso. Aquí la cosa se pone complicada. Existen tipos de datos "opcionales" para ser usados en comparaciones. Con el signo ? puedes decir que una variable puede ser de datos o vacía, con "nil". Ese es el null de Swift.

Código :

   var que_carajo: String? = "WTF"
   que_carajo = nil

   if let contenido = que_carajo
   {
      //no es nil
   }
   else
   {
      //es nil
   }

Yo también estoy confundido.

Swift trae switch, la peor estructura de control de la programación. Con una sintaxis aún más oscura.

Código :

   var pago = "mensual"

   switch(pago) {
   case "mensual":
      var cursos = "todos"
      var duracion = 30

   case "anual":
      var cursos = "todos"
      var duracion = 365

   case "individual", "anual":
      var cursos = "marketing y todos"
      var duracion = 90

   default:
      var que_carajo = "wtf"
   }

Odio switch. Lo odio.

Ciclos

El amigable for-in existe para iterar entre arrays u objetos

Código :

   let numerosRaros = [
       "Primos": [2, 3, 5, 7, 11, 13],
       "Fibonacci": [1, 1, 2, 3, 5, 8],
       "Cuadrado": [1, 4, 9, 16, 25],
   ]
   var masGrande = 0
   for (tipo, numeros) in numerosRaros {
       for numero in numeros {
           if numero > masGrande {
               masGrande = numero
           }
       }
   }
   println(masGrande)

Y Apple hace mucho enfasis en usar "let" en valores fijos y "var" sólo para variables. #justRamThings

Por supuesto, el while también existe, con condiciones similares al if.

Código :

   var n = 2
   while n < 100 {
       n = n * 2
   }
   println(n)
    
   var m = 2
   do {
       m = m * 2
   } while m < 100
   println(m)

¿Y recuerdas declarar una variable iteradora en un ciclo definido? Swift lo hace muy elegante

Código :

var cuentaHastaDiez = 0
var acumula = 0
for i in 0..10 {
   cuentaHastaDiez += 1
   acumula += i
}

O con condiciones

Código :

   var tresCiclos = 0
   for var i = 0; i < 3; ++i {
       tresCiclos += 1
   }

Funciones

Se declaran con func, pueden tener parametros y se les asigna un valor con -> en frente de los parametros. ¿Estamos seguros que no es Actionscript?

Código :

   func despedir(nombre: String, años: Int) -> String{
      return "Hey \(nombre), tras \(años) en la empresa, ¡Estás despedido!"
   }
   despedir("Carlos Paredes", 15)

¿Vieron que escribí "años"? Swift soporta cualquier tipo de carácter ASCII en las variables. Hasta emojis.

Algo muy cool es poder mandar "n" cantidad de parametros

Código :

   func oprah(nombres: String...) -> Int
   {
      var carros = 0
      for nombre in nombres {
         println ("Y \(nombre) tiene un carro nuevo! ")
         carros += 1
      }
      return carros
   }
   autos = oprah("Leonidas", "Harvey", "Diego", "Yohan", "Link")
   println("\(autos) carros entregados")

Y para el momento Xzibit, podemos meter funciones dentro de funciones

Código :

   func xzibit() -> String {
      var mensaje = "Yo "
      func dawg() {
         mensaje += "Dawg!"
      }
      dawg()
      return mensaje
   }
   tweet = xzibit() + String(" I put a closure in your closure")

Las funciones son en si mismas tipos de datos, así que como en Javascript, puedes retornar una función como su propio tipo. Es decir:

Código :

   func xzibit() -> (String -> String) {
      func dawg(cosa: String) -> String {
         return "Yo Dawg! I put a \(cosa) in your \(cosa)"
      }
      return dawg
   }
   subfuncion = xzibit()
   tweet = subfuncion("burrito")
   //Yo Dawg! I put a burrito in your burrito

Ajá, mi mente también duele. Dale tiempo, experimenta. Se pone más jodido cuando descubres que las funciones pueden ser PARAMETROS de otras funciones.

Objetos y Clases

Todos sabemos que es un objeto ¿Verdad? Pues así se hacen en Swift.

Código :

   class Pokemon {
      var nombre: String = ""
      var vida = 100

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

      func herida(fuerza: Int) -> String
      {
         vida = vida - fuerza
         return "\(nombre) es atacado y tiene \(vida) de vida"
      }
   }

Y se instancia

Código :

   var bulbasaur = Pokemon()
   bulbasaur.nombre = "Bulbasaur"
   combate = bulbasaur.herida(10)
   println(combate)

¿Vieron que se inicializa con "init", el constructor? ¿Vieron que existe "self", pero es opcional? Swift también tiene destructores con "deinit".

Y la herencia es tan fácil como declarar una clase de tipo otra clase. También hay sobrecarga de funciones con override.

Código :

   class Pikachu: Pokemon {
      init(nombre: String)
      {
         super.init(nombre)
      }

      override func herida(fuerza: Int) -> String {
         fuerza = fuerza/2 
         //porque pikachu es más fuerte, get it?
         return super.herida(fuerza)
      }

      func impactrueno() -> Int
      {
         return 20
      }
   }

También, en vez de usar variables, puedes usar getters y setters

Código :

   class Pikachu: Pokemon {

      var vida: Int {
         get {
            return vida *2
            //retorna el doble
         }
         set {
            vida = newValue / 1.5
            //sólo le asigna el 50%
         }
      }
   }

Por defecto, el valor de set es "newValue".

También puedes crear "struct" en vez de "class". La diferencia es que una clase tiene herencia, donde una estructura es copiada en vez de referenciada.

Librerías externas

Es tan fácil como hacer import

Código :

   import Love
   var mentiras = Love(true)

Y olvidé las tuplas, enums y otro par de sorpresas. A practicar

Playgrounds Interactivos: Testing en vivo

En XCode ahora puedes crear "Playgrounds" o areas para testear en vivo el código que escribes en Swift. Todo cambia a medida que lo escribes y el area de prueba visual funciona igual que en iOS u OS X.


Ya mismo puedes usar Swift para iOS u OS X bajando el último XCode. Sólo se puede programar en Swift usando un Mac (por ahora) y todas las apps que crees en Swift serán compatibles con iOS 7 y 8, así como OS X Mavericks en adelante.

Si descargas XCode 6 beta, ya estás.

¿Qué tal está Swift? Por favor comparte este tutorial con todos.

¿Sabes SQL? ¿No-SQL? Aprende MySQL, PostgreSQL, MongoDB, Redis y más con el Curso Profesional de Bases de Datos que empieza el martes, en vivo.