tutorial de lenguaje de programación swift

Tutorial de Lenguaje de Programación Swift

Lenguaje de Programación Swift

Introducción:

Swift es un nuevo lenguaje de programación para desarrollar aplicaciones IOS y OS X. Este lenguaje provee sus propias versiones para todos los tipos fundamentales de C y de Objective C, como por ejemplo Int para integers, double y float para valores con coma flotante. Swift también como en C hace uso de variables las cuales tienen un nombre que las identifica y también hace un uso extensivo de variables cuyo valor no puede ser cambiado, las mismas que son conocidas como constantes. Swift introduce tipos avanzados como es el caso de tuplas, las cuales te permiten crear y pasar grupos de valores. Puedes usar una tupla para devolver múltiples valores de una función como si se tratara de un valor único. En Swift también se introducen los tipos opcionales, los mismos que pueden manejar la ausencia de valores.

Constantes y Variables

Las variables y constantes están asociadas a un nombre y ambas pueden tener valores de un tipo en particular, como por ejemplo un número entero o una cadena. Una vez que las constantes son declaradas y asignadas un determinado valor, el mismo ya no puede ser cambiado como si ocurre con las variables.

Declaración de constantes y variables:

Las constantes y variables deben de ser declaradas antes de que sean usadas.

Para declarar una constante se hace uso de la palabra reservada let:

let maximovecestardanza=3

Para declarar una variable se hace uso de la palabra reservada var:

var numerovecestardanza=0

En los ejemplos anteriores podemos tener la situación del número de tardanzas permitidas para los trabajadores de una institución, el mismo que empieza en 0 tardanzas. Aquí hemos declarado una constante llamada maximonovecestardanza cuyo valor constante es de 3 y una variable con el nombre numerovecestardanza cuyo valor inicial es de 0, el mismo que se puede ir incrementando hasta alcanzar el valor permitido de 3.

Se puede declarar múltiples constantes o variables en una sola línea separadas por coma:

let maximotardanzas=3, minimohorastrabajo=8

var nroventas=20, nrohorasextras=0

Autor: Ing. Luis Ernesto Castillo Alfaro


Tipos de Notaciones

Se puede proveer un tipo de notación cuando se declara una constante o una variable, se puede definir del tipo de valores que se pueden almacenar en las mismas durante su declaración haciendo uso de los caracteres 2 puntos (:), su sintaxis es la siguiente por ejemplo al declarar una variable:

var nombrepersona:String

Esto quiere decir que la variable nombrepersona puede almacenar valores de tipo String.

Se pueden definir múltiples variables que almacenen el mismo tipo de valor en una sola línea:

var gandolar,gansoles,ganeuros:Double

El tipo de valor almacenado en las variables anteriores se define luego del nombre de la última variable, para las 3 variables declaradas el tipo de valor a almacenar es Double.

Asignando nombres a variables y constantes

Los nombres de variables y constantes pueden incluir casi cualquier carácter incluyendo caracteres Unicode. Los nombres delas variables y constantes no pueden contener números al inicio de sus nombres pero si ser parte de sus nombres, tampoco pueden contener espacios en blanco, símbolos matemáticos.

Imprimiendo constantes y variables

Se puede imprimir el valor actual de una variable o constante haciendo uso de la función println:

Ejemplo: Tenemos la variable de tipo String nombrepersona cuyo valor actual es Luis y se desea imprimir.

Pasos a seguir:

a- Declarar la variable nombrepersona con su tipo de valor:

var nombrepersona:String

b- Asignamos el valor de la variable nombrepersona:

nombrepersona=”Luis”

c- Imprimimos el valor de la variable nombrepersona:

println(nombrepersona)



Cuyo resultado es: Luis

Hay otra función que nos permite imprimir valores, la cual es print, esta función puede imprimir el valor pasado a ella como por ejemplo:

print(“Luis”)

Esto devuelve como resultado Luis.

Pero si queremos hacer que se concatenen valores de cadena con el valor actual de una variable de nombre nomestudiante, haríamos lo siguiente:

a- Declarar la variable nomestudiante con el tipo de valor a almacenar:

var nomestudiante: String

b- Asignar un valor a la variable nomestudiante:

nomestudiante=”Luis”

c- Imprimir un mensaje que indique cual es el nombre actual del estudiante:

println(“El nombre del estudiante es:\(nomestudiante)”)

Semicolons (punto y coma (“;”)) en Swift

A diferencia de otros lenguajes de programación Swift no requiere que se escriba punto y coma (;) luego de cada declaración en tu código, sin embargo lo puedes hacer si lo deseas:

Puedes declarar una variable con su valor:

Sin punto y coma:

var pais=”Perú”

Con punto y coma:

var pais=”Perú”;

Sin embargo si deseas escribir varias instrucciones en una sola línea, estas deben de ir separadas por punto y coma (;):

var pais=”Perú”; println(pais)



Aquí vemos que primero se está declarando y asignando un valor a la variable pais, para luego imprimir su valor.

Enteros

Los enteros son números que no tienen parte fraccional, como por ejemplo 12 o 15, pueden ser positivos o negativos.

Números con punto flotante

Los números con punto flotante son aquellos que tienen componente fraccional como puede ser: 12.50 o 15.30. Swift provee dos tipos de números de punto flotante:

Double: representa un número de punto flotante de 64 bits.

Float: representa un número de punto flotante de 32 bits.

Operadores básicos

Los operadores son símbolos especiales que permiten verificar, evaluar, cambiar o combinar valores. Por ejemplo el operador matemático de suma (+) permite sumar 2 o más valores numéricos, también por ejemplo tenemos al operador lógico AND o el operador && o también el operador de incremento i++ que permite incrementar el valor de i en 1. Swift soporta la mayoría de operadores de C y mejora muchas capacidades para evitar errores de codificación. A diferencia de C Swift permite trabajar con residuos usando el operador % para números con punto flotante. Swift también provee dos operadores de rango (a..<b y a..b)no encontrados en C como formas de expresar rango de valores.

Terminología de operadores

Los operadores pueden ser: unitarios, binarios y ternarios.

Operadores unitarios: Son aquellos que operan sobre un solo valor como puede ser una variable, estos operadores pueden estar antes o después del valor sobre el cual operan, como por ejemplo:

!b

i++

Operadores binarios: Son aquellos operadores que operan sobre 2 valores y van entre los mismos como por ejemplo:

a+b

Operadores ternarios: Son aquellos operadores que operan sobre 3 valores, en Swift existe un solo operador ternario, el operador condicional ternario:



(a?b:c)

Los valores que son afectados por los operadores son llamados operandos, por ejemplo en:

1+2 , el operador es el símbolo +, mientras que sus operandos son los números 1 y 2.

Operador de asignación:

El operador de asignación es el que inicializa o actualiza el valor de su operando, como por ejemplo en:

let nrohorastrab=8

En el ejemplo anterior vemos que se está inicializando la constante nrohorastrab con el valor de 8.

Otro ejemplo sería en una tupla:

let (x,y)=(1,2)

Donde x tiene el valor de 1

y tiene el valor de 2

Operadores aritméticos:

Swift soporta 4 tipos de operadores aritméticos estándar para cualquier tipo de números:

Adición (+)

Sustracción (-)

Multiplicación (*)

División (/)

El operador aritmético de adición (+) es también utilizado para concatenación de cadenas como por ejemplo:

“Mi nombre es: “+ “Luis Ernesto Castillo Alfaro” cuyo resultado es:

Mi nombre es: Luis Ernesto Castillo Alfaro

Operador de residuo:

El operador de residuo retorna el residuo de una división de un número a entre un número b, por ejemplo si tenemos la operación de 7%4, el residuo es 3.

Cálculo de residuo para números con punto flotante



Al igual que con los números enteros también se puede aplicar el operador de residuo para números con punto flotante:

Por ejemplo tenemos 14%4.5 donde el residuo es 0.50

Operadores de incremento y decremento

Swift provee los operadores de incremento ++ y de decremento --, los cuales incrementan o decrementan el valor de una variable en 1:

Para incremento:

var i=0

++i que significa que i ahora tiene el valor de 1

Para decremento:

Var i=0

--i

Ambos operadores pueden ir antes o luego de una variable. Estos operadores modifican i y también devuelven un valor. Si solo deseas incrementar o decrementar el valor almacenado en i, puedes ignorar el valor retornado.

Si el operador de incremento es escrito como prefijo de una variable, incrementa el valor de la variable antes de retornar su valor.

Ejemplo:

var a=0

let b=++a

Aquí vemos que estamos inicializando la variable a en 0 y luego incrementamos su valor a 1, este nuevo valor de a será también el valor de la constante b.

Si el operador de incremento es escrito como postfijo de una variable, incrementa el valor de la variable luego de retornar su valor.

Ejemplo:

let c=a++

Aquí vemos la constante c que tiene el valor actual de a que es 1, sin embargo luego a tendrá el valor de 2.



Operador unitario menos

Este operador permite cambiar el signo de un valor numérico a negativo si este actualmente tiene un valor positivo, por ejemplo tenemos:

var numero=4

var negnumero=-numero ,cuyo nuevo valor es de -4

Si aplicamos el operador unitario menos a la variable negnumero:

var posnegnumero=-negnumero cuyo nuevo valor es de 4, esto es porque el negativo de un valor negativo es positivo.

Operadores de asignación compuestos

Los operadores de asignación compuestos son los que combinan asignación con otra operación, por ejemplo:

Var a=1

a+=2 cuyo resultado es 3

a+=2 es igual que a=a+2

Operadores de comparación

Swift soporta todos los operadores de comparación estándar de C:

Igual que (a ==b)

No igual que (a !=b)

Mayor que (a>b)

Menor que (a<b)

Mayor o igual que (a>=b)

Menor o igual que (a<=b)

Cada uno de los operadores de comparación retorna un valor de tipo bool para indicar si la declaración indicada es verdadera o falsa:

2==2 resultado verdadero

2!=2 resultado falso

4>3 resultado verdadero



8<7 resultado falso

4>=3 resultado verdadero

12<=11 resultado falso

Los operadores de comparación son usados a menudo en estructuras condicionales:

let estacion=”Invierno”

if estación==”Verano” {

println(“Hay que vestir ropa ligera”

}else{

println(“Es estación :\(estacion), hay que ponerse ropa gruesa”)

}

Operador condicional ternario

El operador condicional ternario es un operador especial que tiene 3 partes y que toma la forma de pregunta en donde si se cumple una condición se evalúa la primera expresión y se retorna su valor, si la condición no se cumple se evalúa la segunda expresión y se retorna su valor.

Estructura:

Pregunta?expresion1:expresion2

Ejemplo:

Se tiene que calcular el sueldo final de cada trabajador de una empresa donde el sueldo básico es de 1000 soles, si el trabajador tiene hijos recibe una compensación de 50 soles por cada hijo, si el trabajador no tiene hijos su sueldo final no se verá afectado.

Solución:

let sbasico=1000

var nrohijos=2

let sfinal=sbasico+(nrohijos>0?:nrohijos*50:0)



Operadores Lógicos

Los operadores lógicos modifican o combinan los valores lógicos boleanos, verdadero y falso. Swift soporta los 3 operadores lógicos estándar encontrados en lenguajes basados en C:

No lógico (!a)

Y lógico (a && b)

O lógico ( a||b)

Operador Lógico No

El operador lógico NO invierte un valor booleano, es decir true se vuelve false y false se vuelve true. El operador lógico NO es un operador de prefijo, es decir se escribe antes del valor sobre el que opera.

Operador Lógico Y

Este operador lógico supone que las 2 condiciones declaradas deben de cumplirse para que se consiga un resultado determinado. Por ejemplo supongamos que deseamos ingresar a un departamento donde solo nosotros sabes el código y además hay un lector de retina para verificar que somos nosotros quienes deseamos ingresar.

let codigocorrecto=true

let lectretinacorr=true

if(codigocorrecto && lectretinacorr) {

println(“Puede ingresar”)

}else{

println(“No puede ingresar”)

}

Operador Lógico O (OR)

Es un operador que evalúa 2 condiciones, en donde solo una de ellas debe de ser verdadera para que el resultado sea verdadero. El operador lógico OR en expresiones lógicas actúa de la siguiente forma:

a- Si la primera expresión a evaluar es verdadera ya no evalúa la segunda expresión y ejecuta las instrucciones indicadas.

b- Si la primera expresión a evaluar es falsa evalúa la segunda expresión y si esta es verdadera ejecuta las instrucciones indicadas.

c- Si ninguna de las expresiones lógicas evaluadas es verdadera entonces no ejecuta las instrucciones indicadas.



Ejemplo: Hay un estudiante de secundaria al que sus padres le darán permiso para ir a una fiesta si por lo menos tiene nota sobresaliente en el curso de Física o de Matemáticas:

Solución:

1- Declaramos las constantes para reflejar si son o no sobresalientes las notas del estudiante en las respectivas materias:

let notsobrfis=TRUElet notsobrmat=FALSE

2- Evaluamos las expresiones lógicas y según eso mostraremos un mensaje que indique si el estudiante puede o no ir a la fiesta:

if notsobrfis || notsobrmat{println(“Puede ir a la fiesta”) }else{println(“No puede ir a la fiesta”)}

Cadenas y caracteres

Una cadena viene a ser un conjunto ordenado de caracteres como por ejemplo: playa, cocina, auto, etc. En Swift las cadenas están representadas por el tipo String, una cadena es una colección de valores de tipo caracter. La concatenación de cadenas es tan fácil como juntar 2 cadenas mediante el operador +. La mutabilidad de cadenas es manejada escogiendo entre una constante o una variable igual como cualquier otro valor en Swift. También se puede usar cadenas para insertar constantes, variables, literales y expresiones dentro de cadenas más grandes en un proceso conocido como interpolación de cadenas.

Literales en Cadenas

Los literales dentro de las cadenas vienen a ser valores predefinidos que se declaran para una variable, constante y que deben de ir dentro de un par de comillas “ “.Por ejemplo tenemos la variable de tipo String msgbienv cuyo valor inicial es: Hola , bienvenido a Perú:

var msgbienv=” Hola , bienvenido a Perú”

Inicializando una cadena vacía

Para inicializar un valor vacío de una cadena como punto de partida de una cadena más grande se puede hacer de 2 formas:

a- Asignando un literal vacío a una variable o constante:

var cadenavacia=” “



b- Inicializando una instancia nueva de String con sintaxis de inicializador:

var otracadvacia= String()

Se puede determinar si una cadena es vacía haciendo uso de su propiedad isEmpty, por ejemplo si tenemos una pantalla de acceso en la que nos solicitan ingresar nuestro usuario y valida que el mismo sea ingresado:

var usuario=” “

if usuario.isEmpty{println(“No ha ingresado su usuario”) }

Mutabilidad de cadenas

Las cadenas también pueden ser modificadas o mutadas cuando se les asigna a una variable en cuyo caso pueden ser modificas, también pueden ser asignadas a una constante, en cuyo caso no pueden ser modificadas.

En el caso de variables:

var mensaje=”Buenos días”mensaje +=”que tal”

Ahora la variable mensaje tiene el valor de: Buenos días que tal

En el caso de constantes:

let texto=”En la pradera española”texto +=”habían 2 granjeros”

Obviamente esto generará un error dado que el valor de una constante de tipo String no puede ser modificado.

Trabajando con caracteres

El tipo String de Swift representa una colección de valores de caracteres en un orden específico, se puede acceder a los valores individuales de estos caracteres iterando una cadena mediante un bucle for-in, por ejemplo:

for character in “Mundo” {println(character)}

Esto haría que se vaya imprimiendo cada caracter de la cadena Mundo.



Concatenando cadenas y caracteres

Se pueden unir 2 cadenas mediante el operador +, por ejemplo:

Tenemos 2 variables de tipo String:

var saludo1=”Hola mundo”var saludo2=” que tal” Uniendo las 2 cadenas:

var saludofinal=saludo1+saludo2

También se puede unir un valor de tipo String con una variable de tipo String mediante el operador de asignación +=.Ejemplo: Tenemos una variable de tipo String con el nombre elsaludo:

var elsaludo=”al Perú”

luego tenemos otra variable de tipo String de nombre nuevosaludo:

var nuevosaludo=”Bienvenido”

Esta última variable la unimos con la variable elsaludo:

nuevosaludo+=elsaludo

El nuevo valor de la variable nuevosaludo es: Bienvenido al Perú.

Se puede unir un valor de tipo caracter con una variable de tipo String mediante el método de tipo String append.

Ejemplo:

Tenemos una constante de tipo Character cuyo valor es:!

let exclamacion:Character=”!”

Tenemos una variable de tipo String de nombre bienvenida:

var bienvenida=”Hola amigo”

Ahora usamos el método append para la variable bienvenida para concatenarlo con el valor de la constante exclamacion:

bienvenida.append(exclamacion)

El resultado es: Hola amigo!



Interpolación de cadenas

La interpolación de cadenas es una forma de construir un nuevo valor de tipo String con la combinación de constantes, variables, literales incluyendo sus valores dentro de un literal de cadena. Cada ítem que se inserte dentro del literal string debe de ir dentro de paréntesis precedido por un backslash.

Ejemplo: Se desea mostrar un mensaje indicando el valor de cuanto es n veces un determinado número.

Solución:

1- Declaramos una variable para el número:

var numero=22- Declaramos una variable para el número de veces a multiplicar el número indicado:

var nveces=4

3- Declaramos una variable que contendrá la siguiente estructura:

var resultado=”\(nveces) veces \(numero) es \(nveces)*\(numero)”

La variable resultado tiene el valor de: 4 veces 2 es 8

Nota: verificar si la sintaxis del valor de la variable resultado es correcto.

Contando caracteres

Para obtener el número de caracteres de una cadena se hace uso de la función countElements cuya sintaxis es:

countElements(cadena)

Ejemplo: Se desea saber el número de caracteres del nombre de un estudiante y mostrarlo en un mensaje.

Solución:

1- Declarar la variable que contendrá el nombre del estudiante:

var nomestudiante=”Carlos Vargas”

2- Declarar la variable que contendrá el mensaje indicando el número de caracteres del nombre del estudiante:

var mensaje=”El nombre \(nomestudiante)tiene \(countElements(nomestudiante)) caracteres”



El valor de la variable mensaje es: El nombre Carlos Vargas tiene 13 caracteres.

Comparando cadenas

Swift provee 3 formas de comparar valores textuales:

- String e igualdad de caracteres- Igualdad de prefijo- Igualdad de sufijo

String e igualdad de caracteres

Cadenas e igualdad de caracteres son verificados mediante el operador igual que (==)y con el operador de no igualdad (!=). Por ejemplo tenemos las siguientes variables con sus respectivos valores de tipo String:

var cadena1=”Mi nombre es Carlos”var cadena2=”Mi nombre es Carlos”

Al evaluar ambas cadenas para verificar si son iguales:

If cadena1==cadena2” {println(“las cadenas son iguales”)}else” {println(“las cadenas no son iguales”)}

El resultado de la evaluación es que ambas cadenas son iguales.

Igualdad de prefijos y sufijos

Para verificar cuando una cadena tiene un determinado prefijo o sufijo se puede utilizar los métodos hasPrefix y hasSuffix, ambos métodos toman un argumento de tipo String y devuelven un valor booleano.

Ejemplo: Se tiene el siguiente array de tipo String en donde se lista una serie de apellidos de trabajadores de una empresa, se desea saber cuántos de ellos tienen un apellido que empiece con el prefijo Ca.

Solución:

1- Definiendo el array de apellidos:

Var listaApellidos=[“Velarde”,”Castañeda”,”Oblitas”,”Caceres”,”Vermudes”,”Carrasco”,”Carbonel”]

2- Declaramos una variable que almacene el número de ocurrencias de trabajadores con apellido que tienen prefijo “Ca”:



var cantapeemca=0

3- Creamos un bucle para que verifique en cada cadena parte del array de apellidos si tiene el prefijo “Ca”, de ser así el valor de la variable cantapeemca debe de incrementarse en 1:

for apellido in listaApellidos{ if apellido.hasPreffix(“Ca”) { ++cantapemca

} }

4- Imprimimos un mensaje que muestre la cantidad de empleados con apellido con prefijo “Ca”:

println(“Hay \(cantapemca)trabajadores que tienen apellido con el prefijo Ca”)

Y el mensaje a mostrar es: Hay 4 trabajadores que tienen apellido con el prefijo Ca.

Tipos de colección

Swift provee 2 tipos de colecciones: Arrays y Diccionarios. Arrays almacenan colecciones ordenadas de elementos del mismo tipo. Diccionarios almacenan colecciones no ordenadas de valores del mismo tipo que pueden ser referenciadas por un único identificador conocido como key. Los arrays y diccionarios en Swift son claros sobre los tipos de valores y keys que pueden almacenar, esto quiere decir que no se puede insertar un valor del tipo incorrecto en un array o diccionario por error.

Mutabilidad de colecciones

Cuando se crean arrays o diccionarios que son asignados a una variable, la colección que se crea es mutable, esto quiere decir que se puede cambiar o mutar la colección luego de ser creada agregando, removiendo o cambiando ítems en la colección. Por el contrario si se asigna un array o un diccionario a una constante, el array o diccionario es inmutable y su tamaño o contenido no pueden ser cambiados.

Arrays

Los arrays almacenan múltiples valores del mismo tipo en una lista ordenada. Los elementos que son parte de un array pueden aparecer múltiples veces en diferentes posiciones. Los arrays son específicos sobre el tipo de valores que pueden almacenar. En un array que almecena valores de un determinado tipo no se puede almacenar otro tipo de valores, por ejemplo si es un array que almacene valores enteros no se podrá almacenar valores que no sean de ese tipo(INT).

Formas de sintaxis de un array

El tipo de Array en Swift puede ser escrito como:



Array<SomeType> donde SomeType es el tipo de valor que el array es permitido almacenar. También se puede escribir el tipo de valor de un array como [SomeType]. Ambas formas son funcionalmente idénticas.

Arrays literales

Se puede inicializar un array con un array literal, que es una forma más corta de escribir una o más valores como parte de una colección en un array. Un array literal es escrito como un conjunto de valores separados por comas y encerrados entre []. En el siguiente ejemplo se tiene un array de tipo String que contiene incialmente 3 elementos referidos a una lista de útiles escolares:

var utilescolar:[String]=[“cuaderno”,”lapicero”,”borrador”]

Se puede apreciar que se declaró una variable para almacenar los valores del array puesto que este puede ser modificado luego, agregando más ítems por ejemplo. Se podría haber obviado el indicar el tipo de valores a almacenar en el array debido a que se está inicializando el array con un array literal conteniendo valores del mismo tipo. La inicialización del array utilescolar se podría haber escrito de la siguiente forma:

var utilescolar=[“cuaderno”,”lapicero”,”borrador”]

Debido a que todos los valores del array literal son del mismo tipo, Swift puede inferir que [String] es el tipo correcto a utilizar para la variable utilescolar.

Accediendo y modificando un array

Se puede acceder y modificar un array por medio de sus métodos y propiedades.

Contando los elementos de un array

Para contar los elementos de un array se utiliza la propiedad “count”.

Ejemplo: Tomando como referencia el array utilescolar que definimos anteriormente tenemos que su cantidad de elementos se puede mostrar en un mensaje:

Solución:

1- Definiendo el array utilescolar:

var utilescolar=[“cuaderno”,”lapicero”,”borrador”]

2- Definimos una variable que almacene la cantidad de elementos del array utilescolar:

var elearrayutesc=utilescolar.count

3- Mostramos el mensaje que indica la cantidad de elementos del array utilescolar:



println(“El array utilescolar tiene \(elearrayutesc)elementos”)

Cuyo resultado es: El array utilescolar tiene 3 elementos.

Hay otra propiedad de los arrays que permite determinar si este tiene o no elementos, es la propiedad boolena isEmpty que verifica si la propiedad count del array es igual 0 o no.

Ejemplo: Determinar si el array utilescolar tiene o no elementos:

Como ya tenemos definido el array utilescolar evaluamos si este es vacío o no:

if utilescolar.isEmpty{

println(“El array está vacío”)

}else{

println(“El array no está vacío”)

}

Agregando nuevos ítems a un array

Se puede agregar un nuevo ítem al final de un array usando el método append. Por ejemplo si deseamos agregar un nuevo ítem al array utilescolar tenemos:

utilescolar.append(“cartuchera”), con esto ahora el array utilescolar tiene 4 items ahora:

[“cuaderno”,”lapicero”,”borrador”,”cartuchera”]

De manera alternativa se puede agregar uno o más ítems del mismo tipo a un array usando el operador de asignación “+=”:

utilescolar +=[“regla”,”plumón”]

Ahora el array utilescolar tiene 6 elementos:

[“cuaderno”,”lapicero”,”borrador”,”cartuchera”,”regla”,”plumón”]

Obteniendo valores de un array

Se puede obtener un determinado valor de un array indicando el índice del valor del array que se desea obtener, dicho índice debe de ir entre corchetes luego del nombre del array:

Nombrearray[índice del valor a obtener]



Por ejemplo si deseamos almacenar el valor del primer elemento del array utilescolar en una variable tenemos:

var elemento1=utilescolar[0], los arrays empiezan con un índice 0 no con un índice de 1.

Ahora el valor de la variable elemento1 es: cuaderno

También se puede cambiar el valor actual de un determinado ítem de un array indicando el índice del mismo:

NombreArray[índice]=nuevovalor

Por ejemplo: Deseamos cambiar el valor del primer ítem del array utilescolar para que ahora sea “escuadra”:

utilescolar[0]=”escuadra”

Es decir el array utilescolar ahora tiene los siguientes elementos:

[“escuadra”,”lapicero”,”borrador”,”cartuchera”,”regla”,”plumón”]

También se puede insertar un ítem en una determinada posición (index) de un array mediante el método insert(atIndex).

La sintaxis para agregar un ítem en una determinada posición de un array es:

NombreArray.insert(valor,atIndex:índice)

Por ejemplo en el array utilescolar:

utilescolar=[“escuadra”,”lapicero”,”borrador”,”cartuchera”,”regla”,”plumón”], se desea insertar el ítem “gomero” en la segunda posición, esto sería:

utilescolar.insert(“gomero”,atIntdex:1)

Ahora el segundo elemento del array utilescolar es gomero:

[“escuadra”,”gomero”,”borrador”,”cartuchera”,”regla”,”plumón”]

Removiendo ítems de un array

Para remover ítems de un array se utiliza el método removeAtIndex, el cual remueve un ítem de un array en una determinada posición y retorna el ítem removido.

Ejemplo: En base al array utilescolar retirar el tercer ítem y almacenarlo en una variable para luego mostrar un mensaje indicando cual fue el ítem que se removió:



Solución:

1- El array utilescolar tiene los siguientes elementos:

utilescolar=[“escuadra”,”gomero”,”borrador”,”cartuchera”,”regla”,”plumón”]

2- Almacenar el valor del tercer ítem a remover en una variable:

var terelemento=utilescolar.removeAtIndex(2)

El valor de la variable terelemento es: borrador

3- Mostramos un mensaje que indique el ítem removido:println(“El elemento removido del array es:\(terelemento)”)

También existe el método removeLast que sirve para remover el último elemento de un array.

Creando e incializando arrays

Se puede crear un array de cierto tipo sin indicar ningún valor inicial usando sintaxis de inicializador.

Por ejemplo tenemos el siguiente array de nombre numeros de tipo entero sin ningún valor inicial:

var numeros=[Int]()

Esto indica que el array números es de tipo Int, de otro lado se puede inicializar dicho array como vacío:

numeros=[]

Diccionarios

Se puede entender a un diccionario como un contenedor que almacena múltiples valores de un mismo tipo, donde cada valor está asociado con un único key que actúa como un identificador para el valor dentro del diccionario. Los ítems de un diccionario no tienen un orden específico. Se deben de usar los diccionarios cuando se tenga la necesidad de tener valores basados en sus identificadores, de la misma forma en que un diccionario de palabras es utilizado para buscar la definición de una palabra en particular. En Swift el tipo de keys y valores que un diccionario puede almacenar es siempre claro.

Tipos de sintaxis para un diccionario

Hay 2 formas de escribir la sintaxis para el tipo Diccionario de Swift:



a- Forma Larga

Dictionary<Key,Value> donde Key es el tipo de valor que puede ser usado como un key de diccionario y Value es el tipo de valor que el diccionario almacena para esos keys.

b- Forma Corta:

También se puede escribir un diccionario de la siguiente forma: [Key: Value].

Ambas formas de sintaxis son funcionalmente idénticas, aunque se suele usar con frecuencia la segunda forma.

Diccionarios Literales

Los diccionarios pueden ser inicializados con un diccionario literal, los diccionarios literales son una forma corta de escribir uno o más pares de key-value como una colección de tipo diccionario. Cada par de key-value son separados por 2 puntos (:), la lista de pares de key-value son separados por comas y encerrados entre corchetes:

[Key1:Value1, Key2:Value2, Key3:Value3]

Tenemos el siguiente ejemplo donde se crea un diccionario que almacenará apellidos y nombres de empleados, donde los keys están formados por 2 caracteres el primero que representa la primera letra del apellido del empleado y el segundo que representa la primera letra del nombre del empleado:

Pasos a seguir:

1- Declaramos una variable para el diccionario a crear:

var Empleados

2- Establecemos el tipo de valores tanto para el key(código empleado) y para el value (nombres empleados):

Como para el key y el value se trata de cadenas usaremos el tipo String para ambos:

var Empleados:[String:String]

3- Ingresamos los valores para el diccionario Empleados:

var Empleados:[String:String]=[“CE”:”Castillo Ernesto”,”DP”:”Deza Pedro”,”AC”:”Armas Carolina”]

Como en el caso de los Arrays, cuando se crea un Diccionario no es necesario de indicar el tipo de diccionario que se está inicializando, como en el caso del Diccionario



Empleados donde los Keys y Values son del mismo tipo, la inicialización del Diccionario Empleados podría haber sido:

var Empleados=[“CE”:”Castillo Ernesto”,”DP”:”Deza Pedro”,”AC”:”Armas Carolina”]

Accediendo y modificando un Diccionario

Un diccionario puede ser accedido o modificado por medio de sus propiedades y métodos o por medio de una sintaxis.

a- Al igual que en los arrays se puede saber la cantidad de elementos de un diccionario usando su propiedad de solo lectura count.

Ejemplo: Teniendo como base el diccionario Empleados mostrar un mensaje que muestre la cantidad de elementos que posee (cantidad de empleados):Pasos a seguir:

1- Crear el mensaje que muestre la cantidad de elementos que tiene el Diccionario Empleados:

println(“Hay \(Empleados.count)empleados actualmente”)

Cuyo resultado es: Hay 3 empleados actualmente.

b- Se puede hacer uso de la propiedad booleana isEmpty para verificar cuando el valor de la propiedad count de un Diccionario es igual a 0. Ejemplo: Imaginemos que hay un restaurante por abrir y que por lo menos necesita de 1 mozo registrado, si no hay ningún mozo contratado, entonces mostrar un mensaje que indique que el restaurante tendrá dificultades para atender al público el primer día de labores.

Pasos a seguir:

1- Declarar la variable que almacenará a los mozos contratados:

var Mozos

2- Ingresar los datos de los mozos al diccionario:

Var Mozos=[Mozo1”:”Carlos Carrión”, “Mozo2”:”José Delgado”]

3- Verificamos si hay mozos contratados:

if Mozos.isEmpty{

println(“No hay mozos contratados”)

}else{



println(“Por lo menos hay un mozo contratado para la apertura”)

}

c- Se pueden agregar nuevos ítems a un Diccionario usando un nuevo Key del tipo apropiado de un índice indicado y asignándole un nuevo valor del tipo apropiado. Ejemplo: En el Diccionario Mozos tenemos 2 elementos, agregar un nuevo elemento:

Mozos[“Mozo3”]=”Antonio Sifuentes”

d- Se puede modificar el valor de un determinado Key de un diccionario por medio de sintaxis:

En el ejemplo anterior se agregó un nuevo mozo al Diccionario Mozos (“Antonio Sifuentes”), ahora se desea modificar el nombre del mismo. Lo que se debe hacer es indicar a que Key del Diccionario Mozos se debe de actualizar su valor:

Mozos[“Mozo3”]=”Antonio Morales”

e- También se puede usar sintaxis para obtener el valor de un determinado key de un diccionario. Por ejemplo si deseamos mostrar en un mensaje el valor del segundo elemento del diccionario Mozos haríamos lo siguiente:

1- Declaramos la variable que almacenará el valor del segundo elemento del diccionario Mozos:

var mozo2=Mozos[“Mozo2”]

2- Creamos el mensaje que mostrará el nombre del segundo mozo:

println(“El nombre del mozo 2 es:\(mozo2)”)

Cuyo resultado es: El nombre del mozo 2 es: José Delgado.

f- Para remover key-value pares de un Diccionario se puede asignarle a un

determinado Key de un diccionario el valor de nil. Por ejemplo se desea retirar el tercer mozo del diccionario Mozos puesto que este mozo ya no labora en el restaurante:

Mozos[“Mozo3”]=nil

Ahora el Diccionario Mozos solo tiene 2 pares de key-value .

Iterando sobre un Diccionario

Se puede iterar sobre los pares key-value de un Diccionario usando un bucle for in. Cada ítem del diccionario es retornado como una tupla (key,value) y se puede descomponer los miembros



de la tupla en variables o constantes como parte de la iteración. Por ejemplo se desea imprimir los keys y valores de los key-value pares del diccionario Empleados:

Pasos a seguir:

1- Tenemos el diccionario Empleados:

var Empleados:[String:String]=[“CE”:”Castillo Ernesto”,”DP”:”Deza Pedro”,”AC”:”Armas Carolina”]

2- Iteramos en el Diccionario Empleados:

for (codempleado:nomempleado)in Empleados{ println(“El empleado:\(nomempleado tiene el código:\(codempleado)”)

}

Cuyo resultado será imprimir los siguientes mensajes:

El empleado: Castillo Ernesto tiene el código:CE

El empleado: Deza Pedro tiene el código: DP

El empleado:Armas Carolina tiene el código:AC

Nota: Dentro del bucle se hace referencia a cada key-value par donde key viene representado por codempleado que hace referencia a cada código de empleado y value viene representado por nomempleado que hace referencia al nombre de empleado en el Diccionario Empleados.

Control de Flujo

Al igual que otros lenguajes parecidos a C, Swift provee las sentencias para el control de flujo. Esto incluye bucles for y while para ejecutar tareas múltiples veces. Sentencias if y switch para ejecutar porciones de código basadas en ciertas condiciones; sentencias como break y continue para transferir el control de ejecución a otro punto en tu código. Adicionalmente al tradicional bucle for, Swift agrega el bucle for-in que hace que sea fácil iterar en arrays, diccionarios, rangos, cadenas y otras secuencias. La sentencia switch de Swift es considerada más poderosa que su contraparte en C. Los casos de la sentencia switch no caen al próximo caso de Swift, evitando los errores comunes de C causados por la falta de sentencias break. Los casos pueden emparejarse con diferentes patrones que incluyen rangos, tuplas y conversiones a un tipo específico. Los valores emparejados en un caso de switch pueden ser almacenados temporalmente en una variable o constante para usarse dentro de los casos, y para emparejar complejas condiciones que pueden ser expresadas con una clausula where para cada caso.

Bucles For



En Swift hay 2 tipos de bucles que ejecutan un conjunto de sentencias un determinado número de veces:

- El bucle for-in ejecutan un conjunto de sentencias por cada ítem en un rango, secuencia, colección o progresión.

- El bucle for ejecuta un conjunto de sentencias hasta que se cumpla una condición específica, típicamente incrementando un contador cada vez que el bucle termina.

Bucle For-in

Se usa el bucle for-in para iterar sobre colecciones de ítems, tal como un rango de números, ítems de un array o caracteres de una cadena.

Ejemplo: Tenemos el siguiente array de nombres:var nombres=[“Carolina”,”Susana”,”Valeria”,”Martha”,”Fernanda”]

Por cada uno de los elementos del array nombres se debe de mostrar un mensaje que vaya imprimiendo cada uno de los nombres:

Solución:

1- Declaramos el bucle:

for nombre in nombres{ println(“El nombre es:\(nombre)”) }

El resultado es:

El nombre es: CarolinaEl nombre es: SusanaEl nombre es: ValeriaEl nombre es: MarthaEl nombre es: Fernanda

También se puede iterar sobre los ítems de un diccionario para acceder a sus pares de key-value. Cada ítem del diccionario es retornado como una tupla key-value cuando el diccionario es iterado y los miembros de la tupla (key,value) pueden ser descompuestos como constantes explicitas para luego ser usadas dentro de bucles for in.

Ejemplo:

Tenemos el siguiente diccionario de nombre emptservicio que hace referencia a empleados de una empresa que tienen un respectivo tiempo de servicio en la misma:

let emptservicio=[“Ernesto Castro”:3,”Juan Aguilar”:4,”Martín Pomar”:5]



Se ha declarado una constante en lugar de una variable pues asumimos que son los únicos trabajadores de la empresa por el momento.

Ahora que ya tenemos declarado el diccionario emptservicio ahora podemos iterar sobre el mismo con un bucle for-in, pero antes debemos de mencionar que cada elemento de key(nombre empleado)-value(tiempo servicio del empleado) del diccionario será almacenado en constantes de nombre nomempleado y tservicio respectivamente:

for (nomempleado,tservicio) in emptservicio{ println(“El empleado: \(nompleado) tiene \(tservicio) años de servicio”) }

Cuyo resultado podría ser:El empleado: Juan Aguilar tiene 4 años de servicioEl empleado: Ernesto Castro tiene 3 años de servicioEl empleado: Martín Pomar tiene 5 años de servicio

Nota: El orden en que los resultados de este ejemplo aparecen no necesariamente tiene relación con el orden en que los ítems del diccionario emptservicio fueron insertados en el mismo.

También se puede usar un bucle for-in para iterar sobre los ítems de una cadena. Por ejemplo tenemos la siguiente cadena:

var mensaje=”Bienvenida”

Usamos un bucle for-in para imprimir cada uno de los caracteres de la cadena mensaje:

for caracter in mensaje{ println(“El caracter es:\(caracter)”)}

Cuyo resultado es:

El caracter es: BEl caracter es: iEl caracter es: eEl caracter es: nEl caracter es: vEl caracter es: eEl caracter es: nEl caracter es: iEl caracter es: dEl caracter es: a



Bucle For

Además de los bucles For-in Swift soporta los tradicionales bucles For que tienen una condición y un incrementador. Por ejemplo: Se desea mostrar en mensajes los primeros 5 números naturales.

Solución:

1- Debemos de tener claro que en estos tipos de bucles se manejan condiciones e incrementadores, entonces debemos de tener una variable que inicialice los números naturales en 1:

var nnatural=1

2- Como los números naturales a mostrar en mensajes van del 1 al 5 debemos de establecer que las sentencias a ejecutar solo se ejecuten hasta que el número natural a mostrar sea menor que 5:

nnatural<5

3- Necesitamos establecer que la variable nnatural se vaya incrementando en 1 su valor cada vez que se ejecute el bucle y para esto declaramos la sintaxis de incremento en 1 para dicha variable:

++natural

4- Declaramos el mensaje a mostrar para cada uno de los números naturales (del 1 al 5):

println(“El número natural a mostrar es:\(nnatural)”)

Ahora la estructura final de nuestro bucle for para este ejemplo es:

for var nnatural=1; nnatural<5;++nnatural{ println(“El número natural a mostrar es:\(nnatural)”)}

Bucles While

Este tipo de bucles ejecutan un conjunto de sentencias hasta que la condición que evalúan es falsa. Existen 2 tipos de bucles While:

- Bucle While: Este bucle evalúa una condición al inicio de cada iteración del bucle.- Bucle Do While: Este bucle evalúa una condición al final de cada iteración del bucle.



Bucle While:

Los bucles while empiezan por evaluar una condición simple, si la condición es verdadera ejecutan un grupo de sentencias hasta que la condición es falsa. La estructura de este tipo de bucle es la siguiente:

while condicion{ sentencias}

Ejemplo: Tenemos el juego del dado donde sabemos que tiene 6 lados, el juego consiste en que cada jugador puede lanzar el dado 4 veces y los lados del dado obtenidos se suman, eso quiere decir que el puntaje máximo es igual a 24, debe de tenerse en cuenta que el puntaje debe de ser inicializado en 0 al igual que el número de veces de lanzar el dado.

Solución:

1- Declaramos las variables para puntaje y para número de veces en lanzar el dado:var puntaje=0var nvtdado=1var vlado=0

2- Establecemos el bucle:

while nvtdado<5{ lanzardado lado=valor del lado del dado puntaje+=lado ++nvtdado}

Para que quede claro explicaré el código escrito en líneas anteriores, como se planteaba en el enunciado el juego consiste en lanzar un dado y que el puntaje inicie en 0, por eso inicializamos la variable puntaje en 0, estamos estableciendo que mientras el número de veces que lance un jugador sea menor a 5 es decir hasta 4 se lanzará el dado el cual tiene valores posibles del 1 al 6 y para esto dentro del bucle se establece la acción de lanzardado luego el valor obtenido de lanzar el dado se le asigna a la variable vlado y ese valor actual de lado es sumado a puntaje, luego se incrementa en 1 el número de veces en que se va a tirar el lado. Vamos a mostrar las iteraciones del bucle suponiendo que los números obtenidos de lanzar el dado para las 4 veces que se lanzó son los siguientes en el orden indicado:

Primera vez que se lanzó el dado: 2Segunda vez que se lanzó el dado: 4Tercera vez que se lanzó el dado: 3Cuarta vez que se lanzó el dado: 5

Primera iteración del bucle:



El valor inicial de nvtdado es 1, la condición evaluada es cierta (1 es menor que 5) y por eso se lanza el dado, el valor del lado es igual a 2, sumamos el valor actual de puntaje(0) con el valor del lado del dado(2) cuyo resultado es 2, el valor de nvtdado se incrementa en 1 (su nuevo valor es 2).

Segunda iteración del bucle:

El valor actual de nvtdado es 2, la condición evaluada es cierta (2 es menor que 5) y por eso se lanza el dado, el valor del lado es igual a 4, sumamos el valor actual de puntaje(2) con el valor del lado del dado(4) cuyo resultado es 6, el valor de nvtdado se incrementa en 1 (su nuevo valor es 3).

Tercera iteración del bucle:


Cuarta iteración del bucle:


Al intentar realizar una nueva iteración del bucle no se ejecuta ninguna sentencia puesto que al evaluar la condición de que nvtdado(5)<5 el resultado es falso.

Si quisiéramos mostrar el puntaje final alcanzado en el juego del dado escribiríamos la siguiente sintaxis:

println(“El puntaje final es:\(puntaje)”)

Cuyo resultado es: El puntaje final es: 14

Bucle Do-while

Este tipo de bucle es una variación del bucle while, se caracteriza por que ejecuta una serie de instrucciones antes de evaluar una condición. La estructura para este tipo de bucles es:

do{ sentencias} while condicion

Si tenemos como base el ejemplo anterior de lanzar el dado la sintaxis para este bucle sería:



do{ lanzardado lado=valor del lado del dado puntaje+=lado ++nvtdado} while nvtdado<5

En este caso se ejecutan 4 iteraciones del bucle, es decir se lanza el dado, se obtiene el valor del lado del dado el cual es asignado a la variable lado y el valor de esta variable sumado al valor de la variable puntaje y finalmente en cada iteración el valor de la variable nvtdado es incrementado en 1, dicho valor es evaluado en la condición de que debe de ser menor que 5. Se realizarán tantas iteraciones siempre y cuando el valor de nvtdado sea menor que 5.

Sentencias condicionales

Es usual ejecutar ciertas porciones de código basadas en ciertas condiciones. Swift provee 2 formas de agregar estructuras condicionales en tu código, las cuales son if y switch . Se suele usar el condicional if para evaluar simples condiciones con solo unos pocos resultados. Se suele utilizar switch para condiciones más complejas con múltiples posibles permutaciones y resulta útil usar este condicional en situaciones donde los patrones de emparejamiento pueden ayudar a ejecutar una apropiada porción de código.

Condicional if

En su forma más simple if tiene una simple condición if que ejecuta un conjunto de sentencias solo si la condición evaluada es cierta. Por ejemplo considerar la situación en la que si nuestra selección de Futbol gana el siguiente partido de preparación entonces se obtendrá una ganancia de 100 soles:

Solución:

1- Declaramos una variable de tipo booleana que indique que la selección gana el partido:

var ganapartido=true

2- Establecemos la estructura condicional para evaluar la condición:

if ganapartido{println(“Ganaste 100 soles”)}

Como vemos en el ejemplo anterior se mostrará un mensaje indicando que se ha ganado 100 soles solo si la condición evaluada es verdadera, pero que sucede si la condición evaluada no se cumple, en ese caso se debería de realizar alguna acción y para esto utilizamos la cláusula else:

if ganapartido{println(“Ganaste 100 soles”)



}else{println(“Perdiste 100 soles”)}

En este segundo caso estamos viendo el mismo ejemplo anterior con la diferencia de que si la condición de que la selección gane el partido no se cumpla se mostrará un mensaje indicando que se ha perdido 100 soles.

Se pueden usar múltiples condicionales if para evaluar diferentes situaciones. Por ejemplo: Mostrar que tipo de estudiante es un estudiante dependiendo del promedio obtenido en un determinado curso:

Solución:

1- Declaramos la variable que almacenará el valor del promedio:

var prom=13

2- Declaramos la estructura para los múltiples casos donde evaluaremos el promedio según el cual debe de indicar los siguientes mensajes:

a- Si el promedio es mayor que 0 y menor que 11 se debe de indicar que el alumno es malo.

b- Si el promedio es mayor que 10 y menor que 13 se debe de indicar que el alumno es flojo.

c- Si el promedio es mayor que 12 y menor que 16 se debe de indicar que el alumno es regular.

d- Si el promedio es mayor que 16 y menor que 19 se debe de indicar que el alumno es bueno.

e- Si el promedio es mayor que los casos anteriores mencionados indicar que el alumno es excelente.

if prom>0 and prom<11{println(“El alumno es malo”)

}else if prom>10 and prom<13{println(“El alumno es flojo”)

}else if prom>12 and prom<16{println(“El alumno es regular”)

}else if prom>15 and prom<19{println(“El alumno es bueno”)

}else{println(“El alumno es excelente”)}

Para el caso evaluado en donde el valor del promedio obtenido por el estudiante (13), se puede apreciar que el resultado será un mensaje indicado que el alumno es regular.



Switch

La sentencia switch toma un valor y lo compara con múltiples posibles valores de coincidencia, una vez que se ha encontrado una coincidencia se ejecuta un determinado conjunto de instrucciones. La sentencia switch es una alternativa a la sentencia if que puede responder a múltiples estados potenciales. Cada sentencia switch consiste de múltiples casos posibles, cada uno de estos casos empieza con la palabra case. El cuerpo de cada caso switch está formado por una porción de código separada a ejecutar. La sentencia switch determina que porción de código debe de ser seleccionada. Cada posible valor considerado debe de ser emparejado con uno de los casos de la sentencia switch, en caso de que no se pueda proveer casos para todos los posibles valores se puede definir un caso default catch-all para todos aquellos casos que no se indicaron explícitamente.

Ejemplo: En un hotel existen diferentes tipos de trabajadores, los cuales son: Empleados identificados con el código emp, Supervisores identificados con el código sup y los gerentes identificados con el código ger, para cada uno de estos tipos de trabajadores existen ciertas funciones del sistema del hotel habilitadas según el tipo de trabajador. Evaluar y mostrar cada una de las funciones habilitadas del sistema según el tipo de trabajador que usa el sistema.

Solución:

1- Declarar una variable que permita almacenar el tipo de trabajador que desea usar el sistema del Hotel:

var tipotrab=” ”

Inicializamos la variable tipotrab como vacía puesto que su valor será proveído por el trabajador que desea usar el sistema del hotel.

2- Evaluamos y mostramos las funciones habilitadas del sistema según el tipo de trabajador, vamos a considerar que en nuestro caso quien desea usar el sistema sea un supervisor:

tipotrab=”sup”

switch tipotrab{ case “emp”:println(“Consultar habitaciones”)println(“Registrar huéspedes”)case “sup”:println(“Consultar empleados”)println(“Registrar horario empleados”)case “ger”:println(“Consultar ingresos hotel por noche”)println(“Imprimir reporte ingresos y egresos hotel”)}

En nuestro ejemplo el tipo de empleado que usa el sistema es un supervisor y por lo tanto tiene habilitada las opciones de consultar empleados y registrar horario de empleados.



Rangos de emparejamiento en sentencia Switch

Los valores de los casos de switch pueden ser chequeados mediante su inclusión en rangos de valores. Por ejemplo teniendo en cuenta la edad de una persona, podremos determinar en qué etapa de su vida se encuentra: si es bebé, niño, adolescente, joven, adulto, adulto mayor, etc.

Solución:

1- Declaramos una variable que almacene el dato de la persona y la inicializamos con un determinado valor:

var edad=12

2- Declaramos una variable de tipo String que almacene la etapa en la que se encuentra la persona según su edad actual:

var etapavida:String

3- Establecemos los distintos casos a evaluar según el valor de la edad de la persona:

switch edad{ case 0...3: etapavida=”un bebé”case 4…11:etapavida=”niño”case 12…17:etapavida=”adolescente”case 18…50:etapavida=”adulto”case 51…80:etapavida=”adulto mayor”}

4- Mostramos un mensaje que nos indique cual es la etapa de la vida según la edad de la persona ingresada:

println(“La persona es:\(etapavida)”)

Según nuestro caso la edad de la persona es de 12 y por lo tanto el valor de la variable etapavida es de adolescente y el mensaje mostrado será: La persona es: adolescente.



Tuplas en sentencias switch

Se pueden usar tuplas para evaluar múltiples valores en una sentencia switch, cada valor de la tupla es comparado con un valor o con un rango de valores. El guión bajo (_) utilizado en una tupla indica que el valor evaluado se podrá emparejar con cualquier valor posible. Por ejemplo tenemos la siguiente tupla de valores enteros que almacenarán calificaciones de los cursos de Matemáticas y Física, según los valores de cada uno de los cursos establecer qué premio o castigo se merecen los estudiantes.

Solución:

1- Declarar la variable que almacenará las calificaciones de ambos cursos:

var calificaciones=(12,17)

2- Establecer las instrucciones a ejecutar por cada uno de los casos de las calificaciones obtenidas por el estudiante en los cursos de Matemáticas (primer valor de la tupla) y de Física (segundo valor de la tupla):

switch calificaciones{case (11…13,11…13): println(“Debe hacer más tareas de Matemáticas y de Física)case (11…13,15…17): println(“Debe hacer más tareas de Matemáticas y con esfuerzo puede ser excelente en Física)case (15…17,11..13): println(“Con esfuerzo puede ser excelente en Matemáticas y necesita más tareas de Física”)case (15…17,15…17): println(“Con esfuerzo puede ser excelente en Matemáticas y en Física”)case (18…20,18…20): println(“El estudiante es excelente en Matemáticas y en Física”)

}En este caso evaluado donde las notas obtenidas por el estudiante en Matemáticas y en Física son de 12 y 17 respectivamente se indica que para el caso de Matemáticas el estudiante debe de hacer más tareas y esforzarse más para ser excelente en Física.

Clausula Where en sentencia switch

Un caso de en una sentencia switch puede usar una clausula where para evaluar condiciones adicionales. (Indagar más y colocar ejemplos)

Funciones

Las funciones contienen porciones de códigos que realizan una tarea específica. Las Funciones poseen un nombre que identifica lo que hacen, y por medio de ese nombre se invoca a las funciones cuando son requeridas para que ejecuten su tarea. La sintaxis unificada para funciones en Swift es lo suficientemente flexible como para expresar



cualquier cosa como funciones sin nombres de parámetros del estilo del lenguaje C o algo más complejo como métodos con parámetros tanto locales como externos con nombres para cada parámetro como en el lenguaje Objective- C. Los parámetros son usados para proveer valores por defecto para simplificar las llamadas a funciones, estos parámetros pueden ser de entrada o de salida, los cuales modifican a una variable una vez que la función ha completado su ejecución. Cada función en Swift tiene un tipo que consiste de los tipos de parámetros y tipos de retorno de la función. Dicho tipo puede ser usado como cualquier otro tipo en Swift lo que hace sencillo pasar funciones como parámetros a otras funciones y retornar funciones de otras funciones. Las funciones también pueden ser escritas dentro de otras funciones para encapsular funcionalidad dentro de una función anidada.

Definiendo y llamando funciones

Al definir una función se le asigna un nombre que identifica lo que dicha función hace, también se definen el o los parámetros y el tipo de los mismos, los parámetros representan valores que serán tomados por la función y que sobre los mismos se realizará alguna acción, de otro lado también se puede definir el tipo de valor que devolverá una función. Se podría considerar que la estructura de una función en Swift sería:

func NombreFuncion(parámetro:Tipo) - > Tipo de Retorno{

Instrucciones

Return valor}

Ejemplo: Crear una función que tenga como parámetro el nombre de una Ciudad y que según ese nombre muestre un mensaje de bienvenida a un turista con la estructura: Bienvenido a la ciudad de: Nombre Ciudad.

Solución:

1- Declaramos el nombre de la función:

Para declarar una función se usa la palabra reservada func:

func BienvCiudad

2- Declaramos el parámetro y el tipo del mismo a ser evaluado por la función:

func BienvCiudad(NomCiudad:String)

3- Declaramos el tipo de valor a retornar por la función:

Para esto usamos una flecha - > seguido del tipo de valor de Retorno que en este caso será una cadena (String):



func BienvCiudad(NomCiudad:String) - > String

4- Declaramos las instrucciones a ejecutar por la función, las mismas que deben de ir entre llaves {}:

func BienvCiudad(NomCiudad:String) - > String{ let saludociudad=”Bienvenido a la ciudad de :” + NomCiudadreturn saludociudad}

Lo que se está haciendo en este punto es declarar una constante cuyo valor siempre será igual a concatenar la cadena Bienvenido a la ciudad de: con el valor de cualquier argumento (nombre de ciudad) que se pase en el lugar del parámetro NomCiudad de la función. En forma práctica llamaremos a la función para el argumento: Trujillo para el parámetro NomCiudad de la función BienvCiudad:

println(BienvCiudad(Trujillo))

Cuyo resultado sería:

Bienvenido a la ciudad de: Trujillo

Parámetros y valores de retorno en variables

Los parámetros y los tipos de retorno en funciones en Swift son bastante flexibles. Se puede definir cualquier cosa desde una simple función con un solo parámetro sin nombrar hasta funciones complejas con nombres de parámetros expresivos y diferentes opciones de parámetro.

Múltiples parámetros de entrada

Las funciones pueden tener varios parámetros de entrada que se colocan entre paréntesis y separados por comas, obviamente cada parámetro debe de indicar el tipo del mismo:

func NombreFuncion(Parámetro1:Tipo,Parámetro2:Tipo)

Imaginemos que tenemos una función que me permite mostrar un mensaje indicando el nombre completo de una persona, en parámetros separados tendremos el nombre y el apellido de la persona:

func NombreCompleto(Nombre:String,Apellido:String) - >String{ return “El nombre completo es:” + Nombre + “ “ + Apellido}

Si aplicamos la función a los parámetros de Olivia para el nombre y Alcantara para el apellido como argumentos para la función tenemos:



NombreCompleto(Olivia,Alcantara)

Esta llamada a la función NombreCompleto la podemos pasar a un mensaje usando la función println:

println(NombreCompleto(Olivia,Alcantara))

Cuyo resultado es: El nombre completo es: Olivia Alcantara.

Funciones sin parámetros

Las funciones no necesariamente tienen que definir parámetros de entrada, por ejemplo tenemos la siguiente función que indica un mensaje de bienvenida a una página de internet a sus visitantes:

Func BienvPagina() - > String{ return “Bienvenido a mi página web Cibernauta” }

Al llamar a la función lo haremos como con cualquier otra función:

BienvPagina()

No importa si la función no tiene parámetros la función debe de llamarse por su nombre seguido de paréntesis, si deseamos imprimir el mensaje de la función usando la función println lo haríamos de la siguiente forma:

println(BienvPagina())

Funciones sin valores de retorno

Las funciones no necesitan definir un tipo de retorno, por ejemplo en la siguiente función donde se ingresan 2 números y se debe de obtener la suma de los mismos e imprimir ese resultado en un mensaje:

func Suma(Numero1:Int,Numero2:Int) { var lasuma=Numero1+Numero2 println(“El resultado de la suma es:\(lasuma)”)}

Como no se retorna ningún valor no se usa la flecha - > ni se define el tipo de retorno. Llamando a la función Suma para los argumentos 3 y 4 tenemos:

Suma(3,4) el resultado que se obtiene es:

El resultado de la suma es: 7.



Funciones con múltiples valores de retorno

Las funciones también pueden retornar múltiples valores como por ejemplo los miembros de una tupla. Planteemos el caso de un array de valores enteros en donde se desea obtener el mínimo y máximo valor, para este caso nuestra función luciría como la siguiente:

func minimomaximo(array:[Int]) - > (min:Int,max:Int) { var minimovalor=array[0] var maximovalor=array[0] for numero in array[1…<array.countElements] { if numero<mimimovalor{ minimovalor=numero }elseif numero>maximovalor{ maximovalor=numero } }return(minimovalor,maximovalor)}

Explicaremos lo que hace esta función, bien en primer lugar la función evaluará un conjunto de valores de tipo entero por eso se declara que el parámetro a evaluar será un array de tipo entero, de la ejecución de la función se obtendrán 2 valores de retorno que en este caso le hemos asignado identificadores uno para el valor mínimo obtenido (min) y otro para el máximo valor obtenido (max). Como no sabemos qué valor es el valor mínimo o máximo del array tomamos como valores iniciales para ambos casos el valor del primer elemento del array. Luego tenemos una variable de nombre número que representa a cada valor del array desde el elemento ubicado en el índice 1 del array hasta el elemento ubicado en el índice igual a la cantidad de elementos del array menos 1, si tenemos un array de 10 elementos la evaluación de este caso en particular desde el elemento ubicado en el índice 1 hasta el elemento ubicado en el índice 9 del array. Si por ejemplo los elementos del array son los siguientes: [10, 5, 13, 4, 2], el valor mínimo y máximo inicial serían el 10, luego para cada uno de los elementos restantes del array evaluará si su valor es menor que 10 si esto es cierto el nuevo valor mínimo será ese valor del elemento en el índice n del array, de no ser menor que 10 será considerado el nuevo valor máximo del array y así sucesivamente hasta que encuentre los valores mínimo y máximo del array. Para este ejemplo el valor mínimo será 2 y el valor máximo será 13. Como hemos indicado que se retornarán múltiples valores para esta función, el resultado de dicha función se puede asignar a variable, por ejemplo:

var mayormenor=minimomaximo[10, 5, 13, 4, 2]

el valor de la variable mayormenor contiene 2 valores de retorno el min y el max definidos como valores de retorno de tipo Int y esto lo podemos asignar a nuevas variables:

var elmimino=mayormenor.min



var elmaximo=mayormenor.max

Podemos imprimir un mensaje indicando los valores resultantes del uso de la función:

println(“El valor mínimo es:\(elminimo) y el valor máximo es:\(elmaximo)”)

Cuyo resultado es:

El valor mínimo es: 2 y el valor máximo es: 13.

Nombres de parámetros de función

Todas las funciones que hemos visto anteriormente definen nombres para sus parámetros:

func NombreFuncion(NombreParametro:Tipo) {

Instrucciones que operan sobre los parámetros}

Dichos parámetros serán luego reemplazados por los argumentos al llamar a las funciones, solo son usados dentro de la definición de la función y por eso se les conoce como parámetros locales.

Nombre de parámetros externos

Cuando se define una función se definen sus parámetros y los nombres de los mismos nos pueden dar idea de su propósito en la función. Puede darse el caso de que hubieran personas a las cuales no se les fuera sencillo leer el código que escribiste en una determinada función, los nombres de parámetros externos nos permiten usarlos al momento de llamar una función y los mismos toman el lugar de los parámetros locales y sus valores vienen a ser los argumentos utilizados al momento de llamar a una función. La estructura de una función que utiliza nombres de parámetros externos es:

func NombreFuncion(Nombre Parámetro externo Nombre Parámetro local : Tipo) {

Instrucciones que operan sobre los parámetros locales}

Ejemplo: Definir una función que use parámetros locales y externos que tenga 2 parámetros locales de tipo String y que permita unir 2 cadenas de texto.

Solución:

1- Definimos la estructura de la función a la que llamaremos unetextos:

func unetextos(Eltexto1 texto1:String, Eltexto2 texto2:String) {



return texto1 + “ “ + texto2}

2- Como se trata de una función que usa parámetros externos la estructura de la llamada a la función deberá ser como la siguiente:

NombreFuncion(Parámetroexterno1: Argumento para el parámetro local1,Parámetroexterno2:Argumento para el parámetro local2)

Entonces para nuestro caso la llamada a la función unetextos sería:

unetextos(Eltexto1:”Hola que tal”,Eltexto2:”como estás”)

El uso de la función debe de retornar: Hola que tal como estás.

Parámetros con valores por defecto

Se puede definir valores por defecto para cualquier parámetro en la definición de una función. Si un valor por defecto es definido, se puede omitir dicho parámetro al momento de llamar a la función. Se debe de colocar los parámetros con valores por defecto al final de la lista de parámetros de la función. Ejemplo: Definir una función que permita unir 3 cadenas de texto, en la función se debe de definir un parámetro que use un valor por defecto.

Solución:

1- Definir la estructura de la función:

func unemastextos(Texto1:String,Texto2:String,Texto3:String=” “){

return Texto1 + Texto3 + Texto2}

Al momento de llamar a la función ya no es necesario declarar el argumento para el tercer parámetro puesto que ya tiene un valor por defecto, entonces al momento de hacer uso de la función podríamos escribir:

unemastextos(“Buenos días”,”como le va”)

Cuyo resultado es: Buenos días como le va.

Parámetros variádicos Los parámetros variádicos son aquellos que pueden aceptar uno o más valores del mismo tipo, este tipo de parámetro es utilizado para especificar que al parámetro se le pueden pasar un número variado de valores de entrada al momento de llamar a la función. Los parámetros



variádicos son fáciles de identificar puesto que en su declaración se identifican por 3 símbolos de puntos luego del tipo de parámetro luego del nombre del parámetro:

func NombreFuncion(Nombreparametro: Tipo …){

Instrucciones a ejecutar por la función}

Los valores que se pasan a un parámetro variádico son considerados en el cuerpo de la función como elementos de un array del mismo tipo. Por ejemplo un parámetro variádico de nombre números y de tipo Double… es considerado como un array constante de tipo Double dentro de la función. El siguiente ejemplo calcula el promedio de un conjunto de valores:

func Promedio(Numeros: Double…) - > Double { var totalsuma:Double=0 for numero in Numeros { totalsuma +=numero } return totalsuma/double(numeros.count) }

Al aplicar la función Promedio a los números: 2,4,6,8,10 el resultado es 6.0.

Tipos de funciones

Toda función tiene un tipo de función específico, el mismo que se compone de los tipos de parámetros y del tipo de valor de retorno de la función. Por ejemplo las siguientes funciones:

func restadosnumeros(numero1:Int,numero2:Int) - > Int{ return numero1 – numero2 }

func dividenumeros(numero1:Int,numero2:Int) - > Double { return numero1/ numero2 }

La primera función puede ser descrita como una función del tipo que toma 2 parámetros de tipo Int y retorna un valor de tipo Int. La segunda función puede ser descrita como una función del tipo que toma 2 parámetros de tipo Int y retorna un valor de tipo Double.

Otro ejemplo de función puede ser:

func Bienvenida(){ println(“Bienvenido al Perú”)}

Esta viene a ser una función que no tiene parámetros y retorna void. Las funciones que no especifican valores de retorno siempre retornan void.



Usando tipos funciones

Antes de explicar este tema tendremos como base la siguiente función:

func sumanumeros(Numero1:Int,Numero2:Int) - > Int { return numero1 + numero2 }

Lo que esta función hace es tomar 2 valores de tipo Int y retornar un valor de tipo Int, en el cuerpo de la función vemos que retorna el resultado de sumar los valores de los parámetros numero1 y numero2. Las variables pueden ser de un tipo en particular como es el caso de ser del tipo función. ¿Cómo hacemos que una variable sea del tipo función? Definiéndola con una estructura idéntica al de una función:

var lasuma: (Int, Int) - > Int=sumanumeros

Como vemos la variable lasuma de tipo función está tomando 2 parámetros de tipo Int y retornará un valor de tipo Int similar como el caso de la función sumanumeros. Ahora esta variable puede ser utilizada para evaluar 2 numeros y retornar el resultado de la suma de los mismos como por ejemplo en un mensaje, teniendo como argumentos los números 4 y 5:

println(“El resultado de sumar 4 con 5 es:\(lasuma(4,5))”)

Cuyo resultado es: El resultado de sumar 4 con 5 es: 9.

Tipos función como tipos de retorno

Se puede usar una función como tipo de retorno de otra función, esto se hace escribiendo un tipo de función completo inmediatamente después de la flecha de retorno (- >) de la función de retorno. El siguiente ejemplo define 2 funciones simples muevehaciadelante y muevehaciatras. La función muevehaciadelante devuelve un valor entero que es igual al valor ingresado como parámetro + 1, la función muevehaciatras devuelve un valor entero que es igual al valor ingresado como parámetro - 1.

La estructura de ambas funciones es:

Función muevehaciadelante:

func muevehaciadelante(Numero:Int) - > Int { return numero + 1 }



Función muevehaciatras

func muevehaciatras(Numero:Int) - > Int { return numero - 1 }

Ahora podemos definir una función que tome como parámetro una de las funciones descritas anteriormente dependiendo de que se cumpla o no una condición lógica, entonces podemos inferir que el parámetro de entrada de esta función debe de ser de tipo booleano (una condición a evaluar):

func escogerfuncion(condicion:bool) - >( Int) - > Int{ return condicion ? muevehaciatras: muevehaciadelante}

La función escogerfuncion es una función que toma como parámetro de entrada una condición lógica a evaluar, si la condición lógica se cumple retorna la función muevehaciatras, si la condición lógica no se cumple retorna la función muevehaciadelante, supongamos que la condición evaluada es que un determinado número sea mayor que 0.

Creamos una variable para el número con un valor inicial de 3:

var numero=3

Evaluando la condición tenemos:

escogerfuncion(numero>0)

Es obvio que 3 es mayor que 0 y como esto es verdadero la función retornada es la función muevehaciatras. La llamada a la función escogerfuncion puede ser asignada a una constante:

let lafuncion=escogerfuncion(numero>0)

Ahora la constante lafuncion tiene como valor la función muevehaciatras. Podemos ir actualizando el valor de la variable número cada vez que llamemos a lafuncion:

numero= lafuncion(numero), ahora por ejemplo el valor de la variable número es 2.

Funciones anidadas

Hasta ahora las funciones que se han visto son funciones de globales, definidas para un ámbito global. También se puede definir funciones en el cuerpo de otras funciones, estas funciones son conocidas como funciones anidadas. Las funciones anidadas están ocultas del mundo exterior por defecto, pero pueden ser llamadas y usadas por sus funciones inclusivas. Una función inclusiva puede incluso retornar una de sus funciones anidadas para ser utilizada en otro ámbito. Teniendo en cuenta la función escogerfuncion se puede volver a escribir usando 2



funciones anidadas, una para incrementar y otra para decrementar un número respectivamente:

func escogerfuncion(condicion:bool) - >( Int) - > Int{ func muevehaciadelante(Numero:Int) - > Int { return numero + 1 } func muevehaciatras(Numero:Int) - > Int { return numero - 1 } return condicion ? muevehaciatras: muevehaciadelante}

Cierres en Swift

Los cierres en Swift vienen a ser bloques que contienen funcionalidad que puede ser pasada y utilizada en código. Los cierres en Swift son similares a los bloques en C y Objective- C. Los cierres pueden capturar y almacenar referencias a cualquier variable o constante en el contexto en el que son definidas. Esto se conoce como cierre sobre constantes y variables. Las funciones globales y anidadas son casos especiales de cierres. Los cierres toman una de las 3 siguientes formas:

- Funciones Globales: Son cierres que tienen un nombre pero no capturan ningún valor.- Funciones Anidadas: Son cierres que tienen un nombre y pueden capturar valores de su

función interior.- Expresiones de cierre: Que no tienen un nombre, son escritas con sintaxis que puede

capturar valores de su contexto.

Expresiones de Cierre

Las funciones anidadas son una forma conveniente de nombrar y definir bloques de código como parte de una función más grande. Sin embargo a veces es más útil escribir versiones más cortas de las funciones como los constructores sin necesidad de una declaración completa, esto suele pasar cuando se trabaja con funciones que usan a otras funciones como sus argumentos. Las expresiones de cierre proveen muchas optimizaciones de sintaxis para escribir cierres en una forma más corta sin perder claridad.

La función de ordenación

La librería estándar de Swift provee una función llamada sorted, la cual permite ordenar un conjunto de elementos del mismo tipo, como puede ser elementos de un array de tipo String. La función sorted toma 2 parámetros:

- Un array de elementos del mismo tipo.- Un cierre que toma 2 argumentos del mismo tipo del contenido del array y que retorna

un valor booleano, para indicar si el primer valor debería de aparecer antes o después del segundo valor una vez que son ordenados. El cierre de ordenamiento necesita



retornar True si el primer valor debería de aparecer antes del segundo valor y retornar False si es al contrario.

Tomemos como base el siguiente array:

let names=[“Claudia”,”Karla”,”Alejandra”,”Beatriz]

Debemos de declarar una sintaxis para nuestro cierre que tome 2 argumentos y que determine si el primer valor debe de ir o no antes del segundo valor:

func vaprimero(valor1: String, valor2: String)- > Bool { return valor1>valor2 }

Esta función toma 2 parámetros de tipo String por ejemplo los elementos del array names: Alejandra y Beatriz que sean sus 2 argumentos, luego de evaluar que Alejandra no es mayor que Beatriz, para cadenas decir que una es mayor que otra significa estar luego de una cadena en orden alfabético, es decir para este caso Alejandra no puede estar luego de Beatriz si no antes.

Podemos declarar una variable que almacene el resultado de la función sorted que tiene como parámetros el array names y la función vaprimero:

var nomordenado=sorted(names,vaprimero) cuyo valor es de:

[“Karla”,”Claudia”,”Beatriz”,”Alejandra”]

Sintaxis de expresión de cierre

La sintaxis de expresión de cierre tiene la siguiente forma general:

{ (parámetros) - >tipo de retorno in Instrucciones a ejecutar}

La sintaxis de la expresión de cierre puede utilizar constantes como parámetros, variables como parámetros, y parámetros inout. También se pueden utilizar parámetros variádicos si los nombras al final de la lista de parámetros. Las tuplas también pueden utilizarse como parámetros y como valores de retorno. El siguiente ejemplo muestra una nueva versión de la función vaprimero usando sintaxis de expresión de cierre:

var ordenado=sorted(names, { (valor1: String, valor2: String)- > Bool inreturn valor1>valor2

})

Vemos que en la declaración de la sintaxis de cierre se usa la palabra in, esto indica que la declaración de parámetros y tipo de retorno ha finalizado y que el cuerpo del cierre está a punto de empezar.



Enumeraciones

Una enumeración define un tipo común para un grupo de valores relacionados y te permite trabajar con esos valores en una forma segura dentro de tu código. Si estás familiarizado con C, sabrás que las enumeraciones de C asignan nombres relacionado a un conjunto de valores enteros. Las enumeraciones en Swift son más flexibles y no tienen que proveer un valor para cada miembro de la enumeración. Si un valor (conocido como valor raw)es proveído para cada miembro de la enumeración, dicho valor puede ser una cadena, carácter o un valor de cualquier tipo entero o de coma flotante. Alternativamente los miembros de la enumeración pueden especificar valores asociados de cualquier tipo para ser almacenados junto con cualquier valor de miembro diferente como en el caso de uniones o variantes de otros lenguajes. Tú puedes definir un conjunto relacionado de valores como miembros de una enumeración, cada uno de los cuales tiene un conjunto de valores diferentes de tipos asociados a los mismos. En Swift las enumeraciones adoptan muchas características soportadas por las clases como por ejemplo propiedades que proveen información acerca del valor actual de la enumeración, e instancia de métodos para proveer funcionalidad relacionada a los valores que la enumeración representa. Las enumeraciones también definen inicializadores para proveer un valor inicial de miembro; puede ser extendida para expandir su funcionalidad debajo de su implementación original, y puede conformar protocolos para proveer funcionalidad estándar.

Sintaxis de enumeración

Para declarar una enumeración se usa la palabra reservada enum y la definición de la misma va dentro de un par de llaves:

enum Emuneracion{ definición de la enumeración}

Un ejemplo de enumeración pueden ser los 4 puntos cardinales de un compás: Norte, Sur, Este y Oeste:

enum PuntCard{ case Norte case Sur case Este case Oeste}

Los valores definidos en una enumeración son los miembros de la misma, como es el caso de Norte, Sur, Este y Oeste para la enumeración PuntCard. La palabra reservada case indica que una nueva línea de valores de miembros está a punto de ser definida.

Nota: A diferencia de C y Objective- C los miembros de una enumeración no tienen valores enteros por defecto asignados como podría pensarse que tuvieran los valores de 0,1,2,3 como es el caso de los miembros de la enumeración PuntCard que tienen valores de Norte, Sur, Este



y Oeste. Miembros de múltiples valores pueden aparecer separados por una coma en una sola línea:

enum Planetas{ case Mercurio, Venus, Tierra, Marte, Júpiter, Saturno, Urano, Neptuno}

Cada definición de enumeración de tipo define un nuevo tipo. Como otros tipos en Swift las enumeraciones deberían de empezar con una letra mayúscula y se les deben de dar tipos singulares en lugar de darles nombres plurales:

var directionToHead=PuntCard.Oeste

El tipo de la variable directionToHead es inferido cuando es inicializada con uno de los posibles valores de la enumeración PuntCard. Una vez que directionToHead es declarada como PuntCard se le puede asignar un nuevo valor usando una sintaxis de punto más corta:

directionToHead= .Norte

El tipo de directionToHead es conocido (PuntCard) y por esto se obvia al asignarle un valor. Esto hace que el código sea más legible cuando se trabaja con valores de enumeración de tipo explícito.

Emparejando valores de enumeración con una sentencia Switch

Los valores de una enumeración pueden ser considerados como casos dentro de una sentencia switch, asi tenemos por ejemplo la variable directionToHead que es considerada del tipo PuntCard que puede tener un valor inicial:

directionToHead= .Sur

Estableciendo la estructura para la sentencia switch:

switch directionToHead{ case .Norte println(“Hace calor”) case .Sur println(“Hace frío”) case .Este println(“Hay que vestir ropa formal”) case .Oeste println(“Debo de comprar un sombrero”)}

Esto quiere decir que en caso que el valor de la variable directionToHead sea igual a uno de los casos indicados en la sentencia Switch se mostrará un mensaje, como la variable directionToHead tiene el valor de . Sur se mostrará el mensaje de: Hace frío.



Valores asociados

Hasta el momento hemos visto enumeraciones con sus respectivos elementos enumerados en diferentes casos como parte de la enumeración, sin embargo también se pueden definir enumeraciones que indiquen que hay valores esperados para cada caso de la enumeración, definiendo previamente el tipo que cada uno de estos casos puede almacenar. Imaginemos la situación en la que se tiene que definir el nivel de atención de una mesera en un restaurante, donde los posibles niveles son: pésimo, regular, excelente y bueno. Según políticas de la administración de dicho restaurante cada uno de estos niveles de atención tienen subniveles que van del 1 al 3, de otro lado los niveles pésimo y regular no son aceptados por lo que representan amonestaciones para las meseras de 30 y 15 soles reducidos de sus salario y descontados tantas veces según el nivel de los mismos. Por ejemplo si una mesera es considerada con nivel de atención de pésimo con una puntuación de 3 se le deberá de hacer un descuento de 90 soles, si la puntuación es de 2 se le descontará 60 soles. Por el contrario si el nivel de la mesera es bueno se le dará una recompensa de 40 soles por el nivel de puntuación adicional a su salario de 600 soles. Si el nivel de puntuación es de 2 para un nivel de atención bueno de una mesera su salario sería igual a 680 soles.

Solución:

1- Establecemos la enumeración para el nivel de atención de la mesera:

enum nivelatencion{ case excelente(Int) case bueno(Int) case regular(Int) case pesimo(Int)}

2- Declaramos una clase mesera que incluya en sus propiedades su nivel de atención y su salario inicial:

class mesera { var tipoAtencion:nivelatencion? var salario=600}

Como vemos hemos creado una clase mesera cuyo valor de su propiedad tipoAtencion es igual a uno de los posibles casos de la enumeración nivelatencion anteriormente definida, de otro lado se definió una propiedad salario para dicha clase cuyo valor inicial es de 600.

3- Creamos un nuevo objeto de la clase mesera y le asignamos un valor inicial de nivel de atención de bueno con una puntuación de 2:

var nuevamesera=mesera()nuevamesera.tipoAtencion=.bueno(2)



4- Se debe de tener en cuenta que la mesera tiene un salario inicial mensual de 600 soles, cada nivel de atención tiene puntuaciones que van del 1 al 3, dependiendo del nivel de atención de una mesera se deben de otorgar premios o castigos monetarios que equivalen al monto por amonestación o premio según nivel de atención multiplicado por su nivel de puntación:

var amonpes=30var amonreg=15var prembue=25var premexc=40

5- Establecemos una estructura switch para evaluar el nivel de atención de la mesera y que junto con su nivel de puntuación decidirán su nuevo salario:

switch nuevamesera.tipoAtencion! {case .pesimo(var nivel): nuevamesera.salario -= nivel*amonpescase .regular(var nivel): nuevamesera.salario -= nivel*amonregcase .bueno(var nivel): nuevamesera.salario += nivel*prembuecase .excelente(var nivel): nuevamesera.salario +=nivel*premexc}

Para nuestro caso la mesera tiene un nivel de bueno con una puntuación de 2, lo que significa que su nuevo salario es de 650 soles.

Valores Raw de miembros de enumeraciones

Este tipo de valores vienen a ser valores que se asignan a los miembros de enumeraciones al momento de la declaración de la misma, estos valores son del mismo tipo para todos los miembros de la enumeración. Al definir la enumeración también se define el tipo de sus miembros:

enum nombreenumeracion:Tipo de valor miembros enumeración{ case miembro1=valor miembro1 case miembro2=valor miembro2 case miembro3=valor miembro3 case miembro4=valor miembro4}

Nota: Los miembros de una enumeración se pueden escribir en líneas separadas antecedidas por la palabra reservada case o en una sola línea separados por coma.



Cuando se definen enumeraciones cuyos miembros tendrán valores de tipo entero se puede obviar el valor de algunos de sus miembros teniendo en cuenta el valor del primero y para los demás miembros su valor será un incremento de 1 en relación al miembro anterior. Por ejemplo teniendo en cuenta la siguiente enumeración:

enum numeros:Int{ case numero1=1,numero2,numero3,numero4,numero5}

Es decir que los valores para los miembros numero2, numero3, numero4, numero5 son 2, 3, 4 y 5 respectivamente.

También se puede acceder a los valores de los miembros de una enumeración por medio de la propiedad rawValue. Por ejemplo teniendo en cuenta la siguiente enumeración:

enum estaciones:String{ case estacion1=”Verano” case estacion2=”Otoño” case estacion3=”Invierno” case estacion4=”Primavera”}

Los valores de los miembros de la enumeración estaciones los podemos almacenar en constantes:

let laestacion1=estaciones.estacion1.rawValue //cuyo valor es: Veranolet laestacion2=estaciones.estacion2.rawValue //cuyo valor es: Otoñolet laestacion3=estaciones.estacion3.rawValue // cuyo valor es: Inviernolet laestacion4=estaciones.estacion4.rawValue // cuyo valor es: Primavera

Clases y estructuras

Las clases y estructuras son constructores flexibles de propósito general que permiten construir bloques de código en tus programas. Las clases y estructuras tienen en común que se les puede agregar propiedades y métodos para proveerles de funcionalidad usando la misma sintaxis como por el ejemplo es el uso d variables, constantes y funciones. A diferencia de otros lenguajes de programación, Swift no requiere crear archivos de interfaces o de implementación de manera separada para clases de usuario y estructuras.

Comparando clases y estructuras

Las clases y estructuras en Swift tienen muchas cosas en común, pero también tienen cosas propias de cada una:

Cosas en común:



- Definen propiedades que permiten almacenar valores.- Definen métodos que les provee funcionalidad.- Definen suscriptores que les proveen acceso a valores mediante el uso de sintaxis de

suscripción.- Definen inicializadores para establecer un estado inicial.- Son expandidas para expandir su funcionalidad por debajo de una implementación por

defecto.- Conforman protocolos para proveer funcionalidad estándar de un cierto tipo.

Las clases tienen capacidades adicionales que las estructuras no poseen:

- Herencia: Que permite que una clase herede las características de otra clase.- Evaluación de tipo: Que permite verificar e interpretar el tipo de una instancia de una

clase en tiempo de ejecución.- Desinializadores: Que permite a una instancia de una clase liberar cualquier recurso

que tiene asignado.- Conteo de referencia: Que permite más de una referencia a una instancia de clase.

Sintaxis de clases y estructuras

Las clases y estructuras en Swift tienen sintaxis de definición similares:

Para las clases:

Para definir una clase se usa la palabra reservada class, seguido del nombre de la clase y entre llaves se define a la clase:

class NombreClase{ Definición de la clase

}

Para definir una estructura se usa la palabra reservada struct, seguido del nombre de la estructura y entre llaves se define la estructura:

struct NombreEstructura{ Definición de la estructura

}

Nota: Cada vez que se define una nueva clase o estructura, se define un nuevo tipo de Swift.

Ejemplo de definición de una clase y de una estructura

struct resolution{ var ancho=0var altura=0

}



class videomode{ var resolucion=resolution() var interlaced=false var frameRate=0.0 var nombre:String?}

El ejemplo anterior define una nueva estructura de nombre resolucion para describir una resolución basada en píxeles. Dicha estructura tiene 2 propiedades ancho y altura de tipo entero que han sido inicializadas a 0. En este ejemplo también se define una clase de nombre videomode que describe un específico modo de video para mostrar video, dicha clase maneja 4 propiedades : resolución que tiene un valor inicial igual a una nueva instancia de la estructura resolución, interlaced que tienen un valor de falso, frameRate con un valor de 0.0 y por último la propiedad nombre con un valor de tipo String opcional.

Instancias de una clase y de una estructura

Hace unos momentos se definió la estructura resolution y la clase videomode, pero eso solo permite ver como lucen y de por si no describen una específica resolution o videomode, para esto podemos establecer instancias de las mismas asignadas como valores de variables o constantes:

var miresolucion=resolution() // se instancia un objeto de la estructura resolutionvar mivideomode=videomode()// se instancia un objeto de la clase videomode

Accediendo a propiedades

Para acceder a las propiedades de una instancia se puede hacer uso de sintaxis de punto (.), se escribe la propiedad inmediatamente después del nombre de la instancia. Por ejemplo si quisiéramos acceder al valor de la propiedad ancho de la instancia miresolucion de la estructura resolución, podríamos definir un mensaje que nos muestre el valor de dicha propiedad:

a- Definimos una variable que almacene el valor de la propiedad ancho:

var elancho=miresolucion.ancho

b- Definimos el mensaje para mostrar el valor de la propiedad ancho:

println(“El valor de la propiedad ancho es:\(elancho)”)

Cuyo resultado es:

El valor de la propiedad ancho es: 0.

También se pueden acceder a subpropiedades como es el caso de la instancia de la clase videomode que tiene una propiedad resolucion que es una instancia de la estructura resolution, en este caso trabajaremos con la propiedad altura de la estructura resolution:



a- Definimos una variable que almacene el valor de la propiedad altura:

var elalto=mivideomode.resolucion.altura

b- Definimos el mensaje para mostrar el valor de la propiedad altura:

println(“El valor de la propiedad altura es:\(elalto)”)

Cuyo resultado es:

El valor de la propiedad altura es: 0.

De otro lado también se puede asignar un nuevo valor a una variable propiedad de una instancia:

var mivideomode=videomode()mivideomode.resolucion.ancho=1280

Valores de inicio para tipos estructura

En Swift también se puede definir un tipo Estructura al establecer una variable o constante como nueva instancia de una estructura, al momento de dicha instanciación también se pueden asignar valores correspondientes a las propiedades de dicha estructura para la variable o constante que se establece del tipo estructura. Por ejemplo en la estructura resolution se definen 2 propiedades de ancho y altura, al establecer una constante como nuevo objeto de eta estructura tenemos:

let miresolucion=resolution(ancho:200,altura:100)

A diferencia de las estructuras, las instancias de una clase no reciben valores de inicio por defecto.

Estructuras y enumeraciones como tipo de valor

Los tipos de valores son aquellos cuyo valor es copiado cuando es asignado a una constante o variable o cuando es pasado a una función. Todos los tipos en Swift: Enteros, números de punto flotante, booleanos, cadenas, arrays o diccionarios son internamente estructuras. Todas las estructuras y enumeraciones son tipos de valores en Swift, esto quiere decir que cuando se crea una instancia de una estructura o enumeración, la misma recibe las propiedades de estas. Anteriormente habíamos definido la estructura resolution:

struct resolution{ var ancho=0var altura=0

}



También habíamos visto que se pueden asignar valores iniciales para las propiedades de una estructura cuando se declara una instancia de dicha estructura:

let miresolucion=resolution(ancho:200,altura:100)

miresolucion es una instancia de la estructura resolution, de otro lado se puede asignar a miresolucion como valor de una variable para que luego esta pueda modificar los valores de las propiedades ancho o altura que la constante miresolucion le pasó:

var nuevaresolucion=miresolucionnuevaresolucion.ancho=250nuevaresolucion.alto=150

Escogiendo entre clases y estructuras

Se pueden usar clases y estructuras para definir tipos de datos que se pueden usar en la codificación. Las instancias de estructuras son pasadas por valores, en cambio las instancias de clases son pasadas por referencias.

Se debe de crear una estructura cuando:

- El propósito principal es encapsular pocos valores de datos relacionados.- Es razonable esperar que los valores encapsulados sean copiados en lugar de ser

referenciados al momento de que se pasan dichos valores en una instancia de dicha estructura.

- Toda propiedad almacenada en una estructura es un tipo de valor y que también puede ser copiada en lugar de ser referenciada.

- Las estructuras no necesitan heredar propiedades o comportamiento de otro tipo existente.

Buenos ejemplos de estructuras pueden ser:

- El tamaño de una figura geométrica, tal vez encapsulando las propiedades de alto y ancho, ambas de tipo Double.

- Una forma de referirse a rangos de una serie, tal vez encapsulando propiedades de inicio y de tamaño de la serie, ambas propiedades de tipo Int.

- Un punto en un sistema de coordenadas en 3D, encapsulando las propiedades de x,y, z, cada una de tipo Double.

En todos los demás casos se debe de definir una clase, y crear instancias de esa clase para ser manejadas y pasadas por referencia. Esto quiere decir que en la práctica la mayoría de constructores de data customizados deberían de ser clases y no estructuras.


tutorial de lenguaje de programación swift

Software