programación – Page 2 – Hola, I'm Geykel

Opcionales en Swift

April 7, 2016May 19, 2017 geykelLeave a comment

El otro día un amigo me comentaba que estaba implementando un juego para probar Swift por primera vez y me contaba que estaba teniendo problemas entendiendo algunas cosas de los opcionales (optionals) en Swift. Pensé que era un buen tema para escribir un pequeño post y de paso generar un poco de documentación en Español, lo cual es uno de los principales propósitos de este blog.

Opcionales

Según la documentación de Swift,

Los opcionales se utilizan en situaciones donde el valor puede estar ausente.

Este concepto no existe en Objective-C, en el cual es permitido incluso enviar un mensaje a nil. Lo más cercano a representar ausencia de valor es retornando nil en métodos que de otra manera deberían devolver un objeto, pero esto solo funciona con objetos y no con enumeraciones, estructuras y tipos básicos de C para los cuales generalmente se utiliza NSNotFound para representar ausencia de valor; en dependencia del tipo, algunos desarrolladores también utilizan 0, -1, NSIntegerMax y cosas parecidas.

Continue reading “Opcionales en Swift” →

Selector, su evolución en Swift

March 24, 2016May 19, 2017 geykelLeave a comment

Antes de ver la evolución de los selectores en Swift, veamos qué es un selector en Objective-C.

Los selectores en Objective-C son del tipo SEL y es la manera mediante la cual podemos identificar/seleccionar un método y luego poder ejecutarlo en un objeto.

Las formas más comunes de obtener un selector son a través de la directiva @selector y la función NSSelectorFromString, veamos como se utilizan ambas:

SEL selector1 = @selector(calcularArea);
SEL selector2 = NSSelectorFromString(@"calcularArea");
SEL selector3 = @selector(avanzar:);
SEL selector4 = NSSelectorFromString(@"avanzar:");

En las líneas 1 y 2 representamos a un método que no tiene argumentos “calcularArea” y en la 3 y 4 representamos a un método con un argumento “avanzar:”.

Continue reading “Selector, su evolución en Swift” →

Enumeraciones en Swift

December 5, 2015May 19, 2017 geykelLeave a comment

Enumeraciones es otro tema que quería tratar antes de continuar con la serie de tutoriales de Gorilla Rush.

Como seguramente saben de otros lenguajes de programación, una enumeración define un tipo común para un grupo de valores que están relacionados entre sí.

Sintaxis

La sintaxis para definir una enumeración es:

	enum UnaEnumeracion {
	// aquí va la definición
	}

view raw

UnaEnumeracion.swift

hosted with ❤ by GitHub

El siguiente ejemplo, muestra una enumeración que agrupa las posiciones en el campo de béisbol:

	enum PosicionesCampoBeisbol {
	case Lanzador
	case Receptor
	case PrimeraBase
	case SegundaBase
	case TerceraBase
	case Campocorto
	case JardineroIzquierdo
	case JardineroCentral
	case JardineroDerecho
	}

view raw

PosicionesCampoBeisbol.swift

hosted with ❤ by GitHub

Como pudieron ver, se utiliza la palabra clave case para definir los valores de la enumeración, aunque de igual manera pueden colocar múltiples valores separados por coma en una misma línea como se muestra en el siguiente ejemplo, donde definimos una enumeración con los días de la semana:

	enum DiasSemana {
	case Lunes, Martes, Miercoles, Jueves, Viernes, Sabado, Domingo
	}

view raw

DiasSemana.swift

hosted with ❤ by GitHub

En otros lenguajes de programación se les asigna a cada valor de la enumeración un valor entero, en Swift las enumeraciones son más flexibles ya que no tienes que obligatoriamente proporcionar un valor a los valores de la enumeración y si decides hacerlo, este valor puede ser una cadena, un caracter, entero o punto flotante; este valor en Swift se conoce como valor “raw”.

Continue reading “Enumeraciones en Swift” →

Protocolos en Swift (básico)

November 17, 2015January 28, 2016 geykel2 Comments

Antes de continuar con la serie de tutoriales sobre como crear un juego como Gorilla Rush, me pareció útil escribir un par de post acerca de algunas características de Swift, las cuales vamos a utilizar en los tutoriales.

En esta ocasión voy a hablar acerca de protocolos. Los protocolos probablemente sea algo nuevo para ti, pues si tienes experiencia en lenguajes como C# o Java seguramente has utilizado o leído sobre interfaces… bueno, eso es lo que un protocolo es en Swift.

No vamos a entrar en muchos detalles en este post sobre qué es una interfaz o protocolo, o cuándo usarlos o cuándo no, sobre esto hay bastante documentación en la web. Vamos en enfocarnos más en cuál es su sintaxis en Swift y algún que otro ejemplo.

En Swift, un protocolo es como un plano, que define métodos, propiedades y otros requerimientos que responden a una tarea en particular. Puede ser adoptado por una clase, estructura o enumeración con el objetivo de brindar una implementación a estos requerimientos. Cualquier tipo que implemente un determinado protocolo se dice que implementa (o se ajusta) a ese protocolo.

Sintaxis

Un protocolo se define de forma muy similar a una clase, estructura o enumeración:

	// sintaxis de un protocolo
	protocol UnProtocolo {
	// aquí va la definición
	}

view raw

UnProtocolo.swift

hosted with ❤ by GitHub

Para que un tipo pueda adoptar/implementar un protocolo, debe colocar el nombre del protocolo luego del nombre del tipo separados por el signo de dos puntos como parte de su definición, el tipo puede implementar más de un protocolo colocándolos separados por coma:

	// estructura que implementa dos protocolos
	struct UnaEstructura: UnProtocolo, OtroProtocolo {
	// aquí va la definición
	}

view raw

UnaEstructura.swift

hosted with ❤ by GitHub

Si una clase hereda de una super clase, coloca primero la superclase y luego los protocolos que implemente separados por coma:

	// clase que hereda de una super clase e implementa dos protocolos
	class UnaClase: SuperClase, UnProtocolo, OtroProtocolo {
	// aquí va la definición
	}

view raw

UnaClase.swift

hosted with ❤ by GitHub

Ejemplo

Antes de continuar veamos un ejemplo.

	// 1
	protocol Hablar {
	func decirHola(nombre: String)
	}

	// 2
	class Persona: Hablar {
	// 3
	func decirHola(nombre: String) {
	// 4
	print("Hola (nombre).")
	}
	}

	// 5
	var juliana = Persona()
	var geykel = Persona()

	// 6
	juliana.decirHola("Geykel")
	geykel.decirHola("Juliana")

view raw

PersonaHablar.swift

hosted with ❤ by GitHub

Primero definimos el protocolo Hablar el cual contiene un método, decirHola(nombre: String).
Definimos la clase Persona que va a adoptar/implementar el protocolo Hablar.
Brindamos una implementación al método decirHola(nombre: String) en la clase Persona.
Este método sólo va a imprimir el texto “Hola” seguido del valor que se le pase a través de la variable nombre que es de tipo String.
Creamos dos variables con los nombres juliana y geykel, ambas guardan una referencia a un objeto de tipo Persona.
Finalmente invocamos el método decirHola en ambas variables y el resultado que veremos serán dos lineas, la primera: “Hola Geykel.”, y la segunda: “Hola Juliana.”.

Propiedades

En Swift un protocolo puede también requerir al tipo que lo implemente, definir propiedades, especificando el nombre y el tipo de la propiedad y si la misma servirá sólo para obtener un valor o si además permitirá establecer un valor.

El siguiente ejemplo muestra los dos casos:

	// ejemplo de protocolo con propiedades
	protocol UnProtocolo {
	var permiteEstablecerYDevolverUnValor: String { get set }
	var permiteSoloDevolverUnValor: Int { get }
	}

view raw

UnProtocoloPropiedades.swift

hosted with ❤ by GitHub

La primera propiedad especifica que puede tanto establecer un valor como devolver un valor, y la segunda sólo devolver.

En la definición de propiedades en un protocolo no se especifica si son propiedades cuyo valor es calculado o si sólo es una propiedad para almacenar un valor; es responsabilidad del tipo que implemente el protocolo decidir esto.

En el siguiente ejemplo veremos un caso de propiedad calculada:

	// 1
	protocol NombreCompleto {
	var nombreCompleto:String { get }
	}

	// 2
	class Persona: NombreCompleto {
	// 3
	var nombre: String
	var apellidos: String

	// 4
	init(nombre: String, apellidos: String) {
	self.nombre = nombre
	self.apellidos = apellidos
	}

	// 5
	var nombreCompleto: String {
	// 6
	return "(nombre) (apellidos)"
	}
	}

	// 7
	var juan = Persona(nombre: "Juan", apellidos: "Pérez")
	// 8
	print(juan.nombreCompleto)

view raw

ProtocoloPropiedadCalculada.swift

hosted with ❤ by GitHub

Definimos el protocolo NombreCompleto el cual provee una definición de la propiedad nombreCompleto: String { get } la cual sólo puede ser utilizada para devolver un valor debido a que no contiene un set.
Definimos la clase Persona que implementa el protocolo NombreCompleto.
Definimos dos atributos de la clase Persona, nombre y apellidos de tipo String.
Creamos un inicializador (conocido en otros lenguajes como constructor) el cual inicializa los atributos de la clase Persona.
Ahora implementamos la propiedad nombreCompleto que adoptamos del protocolo NombreCompleto.
Como desarrollador de la clase he decidido que el valor retornado por esta propiedad es calculado y es el resultado de concatenar el valor de los atributos nombre y apellidos.
Creamos una variable llamada juan la cual guarda una referencia a un objeto de tipo Persona, este objeto fue creado utilizando el inicializador que definimos en el paso 4.
Llamamos a la función print para visualizar el valor de la propiedad nombreCompleto el cual es “Juan Pérez”.

Esto es todo lo que quería cubrir en este post, es más que suficiente para cubrir las bases para la serie de tutoriales sobre Gorilla Rush.

Hay mucho más sobre protocolos en Swift, incluso algunas funcionalidades que no había visto antes en lenguajes como Java y C#. Si deseas conocer más puedes consultar la guía de Swift en el sitio para desarrolladores en Apple.