ATENCIÓN: este contenido tiene más de 2 años de antigüedad y, debido a su temática, podría contener información desactualizada o inexacta en la actualidad.
El objetivo de este post es mencionar 5 ideas interesantes que incorpora el nuevo lenguaje de desarrollo de Apple y que han sido sacadas de otros lenguajes más o menos populares. Que una idea esté sacada de otro lenguaje es lo normal: hoy en día los nuevos lenguajes se crean a partir de los existentes mezclando conceptos de cada uno de ellos, en base a la orientación y a la filosofía con la que se quiera dotar el lenguaje.
Tómate esta lista de 5 ideas como un ejemplo: no están todas las ideas de Swift. Simplemente hemos elegido cinco de ellas y las mostramos aquí.
¡Empecemos, pues!
1. Inferencia de tipos
Swift es un lenguaje con tipado estático: eso significa que todas las variables tienen un tipo de compilación y que el compilador comprobará que el valor asignado se corresponda al tipo de la variable. La inferencia de tipos es la capacidad del compilador de detectar el tipo de una variable en base a la expresión que se le asigna. Así pues en Swift podemos declarar una variable así:
var str = "Hello World"
Eso declara una variable llamada str y cuyo tipo se deduce a partir de la expresión situada a la derecha del operador de asignación. En este caso, como "Hello World" es una cadena, la variable str es de tipo String. Si queremos podemos especificar el tipo de la variable pero no estamos obligados a ello:
var str : String = "Hello World"
Tan solo debemos especificar el tipo cuando deseamos declarar una variable sin asignarle un valor inicial: en este caso dado que no hay expresión que permita deducir el tipo de una variable debemos indicarla explícitamente:
var str // Error
var str : String // OK
Esta característica se encuentra en otros lenguajes como C# (aunque a diferencia de C#, Swift permite inferir el tipo de constantes) o como C++11. ¡No la confundas con la declaración de variables de un lenguaje dinámico como JavaScript!
2. Operador de rango
El operador de rango (...) permite definir directamente un rango de valores. Los rangos son un tipo de datos válido por lo que pueden ser asignados a variables:
var range = 1...10
Los rangos pueden iterarse:
for value in range { }
Y por supuesto el operador de rango no está limitado a constantes:
var from = 2
var to = 12
var range = from...to
Esta característica se encuentra en lenguajes como Python
3. Punto y coma no (pero bueno, si lo pones no pasa nada)
Swift elimina la necesidad de usar el punto y coma para separar sentencias que estén en líneas separadas, pero si lo usas no genera ningún error. Así ambas líneas de código son válidas:
var start = 10
var start = 10;
Eso sí, el punto y coma sigue siendo obligatorio para separar sentencias en una misma línea:
var from =10; var to=20 // El ; después del 10 es obligatorio. Después del 20 puede venir o no (al ser la última sentencia de la línea).
Esta característica se encuentra, aunque con ciertas diferencias, en JavaScript.
4. Tuplas
Las tuplas se incorporan como tipo nativo del lenguaje:
var tuple = (1,2,3)
var first = tuple.0 // first valdrá 1
Las tuplas se pueden pasar como parámetros o ser devueltos por una función:
func getTuple() -> (Int, Int, Int) {
return (1,2,3)
}
var tuple = getTuple()
println (tuple.0)
Las tuplas pueden tener parámetros nombrados lo que reduce mucho la necesidad de crear clases que se usan una sola vez:
func getFullName() -> (name: String, lastName: String) {
return ("Super", "Lopez")
}
var tuple = getFullName()
println (tuple.name) // tuple.0 sigue funcionando
Esta característica se encuentra en Pyhton o Scala. Casi cualquier lenguaje tiene soporte para tuplas, pero no todos lo tienen integrado como un tipo "nativo" del lenguaje.
5. Enumeraciones
Muchos lenguajes soportan enumeraciones, pero pocos las tienen tan potentes como las de Swift. Así las enumeraciones pueden tener métodos e implementar interfaces (protocolos en la jerga de Swift). La declaración de enumeraciones es muy sencilla:
enum Features {
case Basic, Advanced
}
A diferencia de muchos lenguajes (tales como C ó C#) las enumeraciones no tienen una correspondencia con un valor entero.
Para implementar un protocolo:
// Define un protocolo (interfaz) con un método Bar
protocol DescProtocol {
func Description () -> String
}
enum Features : DescProtocol {
case Basic, Advanced
func Description() -> String {
switch (self) {
case .Basic:
return "Basic features only"
case .Advanced:
return "Advanced features on"
}
}
}
// Declaramos una variable de tipo Features
var features = Features.Advanced
println(features.Description())
// Declaramos una variable de tipo DescProtocol
var descriptable : DescProtocol = Features.Basic
println(descriptable.Description())
Esta capacidad de las enumeraciones de tener métodos se puede encontrar en Java.
Estas son solo 5 características a modo de ejemplo que se pueden encontrar en Swift... ¡Por supuesto hay otras que iremos explorando en sucesivos posts!
Y a ti, ¿cuáles son las características de Swift que más te gustan?
Fecha de publicación: