{"id":486,"date":"2017-12-07T06:00:26","date_gmt":"2017-12-07T05:00:26","guid":{"rendered":"http:\/\/www.programaraciegas.net\/?p=486"},"modified":"2017-11-30T05:57:13","modified_gmt":"2017-11-30T04:57:13","slug":"control-de-flujo-de-la-aplicacin-usando-estructuras-condicionales","status":"publish","type":"post","link":"https:\/\/programaraciegas.net\/?p=486","title":{"rendered":"Control de flujo de la aplicación usando estructuras condicionales en Swift"},"content":{"rendered":"

En Swift al igual que en otros lenguajes de programación la ejecución de un programa cambia según se vayan cumpliendo una serie de condiciones. Por esta razón todos los lenguajes de programación incluyen algún tipo de estructura condicional para poder controlar el flujo de ejecución de nuestro programa.<\/p>\n

La mayoría de estructuras condicionales cumplen esta estructura:<\/p>\n

\r\nSi se cumple una condición\r\nentonces haz algo\r\n<\/pre>\n<\/p>\n
Esto en Swift se consigue con la sentencia if<\/strong> y su sintáxis es la siguiente:<\/p>\n

\nif condicionVerdadera {
\n  \/\/ Codigo a ejecutar si se cumple la condicion
\n}
\n<\/code><\/p>\n
La condición siempre será una comparación booleana (devolverá verdadero o falso) y sólo se ejecutaría el código entre llaves si la comparación es verdadera.<\/p>\n
Veamos un ejemplo sencillo.<\/p>\n

\n\/*
\n  Playground de ejemplo de condicionales
\n*\/
\nlet num1 = 23
\nlet num2 = 33<\/p>\n
if num1 < num2 {\n  print(\"Num1 es menor que num2\")\n}\nif num1 > num2 {
\n  print(\"Num1 es mayor que num2\")
\n}
\nif num1 == num2 {
\n  print(\"Num1 es igual que num2\")
\n}
\n<\/code><\/p>\n
Comparaciones en Swift<\/h3>\n
La mayoría de comparaciones que se realizan en Swift son comparaciones de valores almacenados por variables u objetos. En Swift tenemos inicialmente las siguientes operaciones de comparación:<\/p>\n
\n
==<\/dt>\n
Igual a<\/dd>\n
!=<\/dt>\n
distinto de<\/dd>\n
<<\/dt>\n
Menor que<\/dd>\n
><\/dt>\n
mayor que<\/dd>\n
<=<\/dt>\n
Menor o igual que<\/dd>\n
>=<\/dt>\n
mayor o igual que<\/dd>\n<\/dl>\n
Con este conjunto de comparaciones podemos resolver la mayoría de progremas de cualquier aplicación.<\/p>\n
Ámbitos en Swift<\/h3>\n
En Swift el uso de las llaves ({ }<\/em>) se utiliza para agrupar un trozo de código que pertenecerá a un mismo ámbito.<\/p>\n
Los ámbitos no sólo se utilizan para determinar qué conjunto de órdenes pertenecen a una función, parte de código a ejecutar si se cumple una condición o qué funciones y propiedades pertenecen a una clase. Un ámbito también determina qué recursos están fuera y dentro del ámbito. Esto significa que podemos usar variables y constantes que estén por encima del ámbito pero todo aquello que declaremos dentro del ámbito no podrá ser utilizado fuera de él.<\/p>\n
Veamos esto en un ejemplo de código.<\/p>\n

\n\/*
\n  Playground de ejemplo de ambitos en Swift
\n*\/<\/p>\n
let numFuera = 3
\ndo {
\n  let numDentro = 5
\n  print(\"fuera= \\(numFuera) dentro = \\(numDentro)\")
\n}
\nprint(\"fuera= \\(numFuera) dentro = \\(numDentro)\")
\n<\/code><\/p>\n
Si intentamos ejecutar el código anterior obtendremos el siguiente error:<\/p>\n
\r\nPlayground execution failed:\r\n\r\nerror: PlayGroundTest.playground:4:38: error: use of unresolved identifier 'numDentro'\r\nprint(\"fuera= \\(numFuera) dentro = \\(numDentro)\")\r\n                                     ^~~~~~~~~\r\n<\/pre>\n<\/p>\n
Esto se debe a que en la última línea de código, en el segundo uso de la función print() estamos haciendo referencia a la constante numDentro<\/em> que está declarada dentro de un ámbito y esa función print() está siendo ejecutada fuera de ese ámbito.<\/p>\n
Veremos más adelante más detalles de los ámbitos. Por ahora sólo nos interesa saber que las llaves nos permiten crear bloques de código agrupado y que los recursos creados y declarados dentro de un bloque son para ser utilizados dentro de ese bloque o dentro de los sub bloques que contenga.<\/p>\n
Encadenando y anidando condicionales<\/h3>\n
Relacionada con la sentencia if<\/strong> tenemos la sentencia else<\/strong> que nos permite ejecutar un bloque de código si no se cumple la condición que estamos evaluando. Sería algo como:<\/p>\n
\r\nSi se cumple una condición\r\n  entonces haz algo\r\nSi no \r\n  entonces haz otra cosa\r\n<\/pre>\n<\/p>\n
Con la sintáxis de Swift el ejemplo sería el siguiente:<\/p>\n

\nif condicionVerdadera {
\n  \/\/ Codigo a ejecutar si se cumple la condicion
\n} else {
\n  \/\/ Codigo a ejecutar si no se cumple la condicion
\n}
\n<\/code><\/p>\n
Un ejemplo práctico podría ser este:<\/p>\n

\n\/*
\n  Playground de ejemplo de condicionales
\n*\/
\nlet num1 = 23
\nlet num2 = 33<\/p>\n
if num1 < num2 {\n  print(\"Num1 es menor que num2\")\n} else {\n  print(\"Num1 no es menor que num2\")\n}\n<\/code><\/p>\n
Podemos encadenar varios else if<\/strong> para optimizar nuestro código. Nuestro ejemplo inicial quedaría de la siguiente forma:<\/p>\n

\n\/*
\n  Playground de ejemplo de condicionales
\n*\/
\nlet num1 = 23
\nlet num2 = 33<\/p>\n
if num1 < num2 {\n  print(\"Num1 es menor que num2\")\n}\nelse if num1 > num2 {
\n  print(\"Num1 es mayor que num2\")
\n}
\nelse if num1 == num2 {
\n  print(\"Num1 es igual que num2\")
\n}
\n<\/code><\/p>\n
Además dentro de un dominio de una condición podemos incluir nuevas condiciones creando condiciones anidadas. Veamos un ejemplo práctico<\/p>\n

\n\/*
\n  Playground de ejemplo de condicionales
\n*\/
\nlet num1 = 23
\nlet num2 = 33<\/p>\n
if num1 < num2 {\n  if num1 == 23 {\n    print(\"Num1 es menor que num2 y num1 tiene el valor 23\")\n  } else {\n    print(\"Num1 es menor que num2\")\n  }\n} else {\n  print(\"Num1 no es menor que num2\")\n}\n<\/code><\/p>\n
Realizando varias comparaciones a la vez<\/h2>\n
En algunas ocasiones puede que una condición consista en el resultado de varias comparaciones. Swift, al igual que otros lenguajes de programación nos permite conjuntar comparaciones para crear una condición compuesta.<\/p>\n
Para poder crear estas uniones entre comparaciones tenemos las palabras AND<\/em> y OR<\/em> qe nos permiten crearr combinaciones más complejas. Pero en Swift en lugar de utilizar la palabra AND<\/em> debemos usar el doble símbolo de ampersand (&&<\/em>) y para la palabra OR<\/em> debemos usar el doble símbolo de línea vertical (||<\/em>).<\/p>\n
Si utilizamos el AND<\/em> indicamos que ambas comparaciones deben cumplirse para que la condición sea verdadera. Pero si utilizamos el OR<\/em> sólo necesitamos que se cumpla una de las comparaciones para considerar que la condición se cumple.<\/p>\n
Veamos un ejemplo de código<\/p>\n

\n\/*
\n  Playground de ejemplo de condiciones compuestas
\n*\/<\/p>\n
let num1 = 10
\nlet num2 = 20
\nvar num3 = num2 \/ num1
\nvar num4 = 2<\/p>\n
if num1 < num2 && num3 == num4 {\n  print(\"num1 es menor que num2 y num3 es igual que num4\")\n} else {\nprint(\"No se cumple la condici\u00f3n de num1 es menor que num2 y num3 es igual que num4\")\n}\n\/\/ cambiamos el valor de num4\nnum4 = 4\nif num1 < num2 && num3 == num4 {\n  print(\"num1 es menor que num2 y num3 es igual que num4\")\n} else {\nprint(\"No se cumple la condici\u00f3n de num1 es menor que num2 y num3 es igual que num4\")\n}\n\n\/\/ Cambiamos and por or\nif num1 < num2 || num3 == num4 {\n  print(\"num1 es menor que num2 o num3 es igual que num4\")\n} else {\nprint(\"No se cumple la condici\u00f3n de num1 es menor que num2 o num3 es igual que num4\")\n}\n<\/code><\/p>\n
Al ejecutar este código obtendremos este resultado:<\/p>\n
\r\nnum1 es menor que num2 y num3 es igual que num4\r\nNo se cumple la condici\u00f3n de num1 es menor que num2 y num3 es igual que num4\r\nnum1 es menor que num2 o num3 es igual que num4\r\n<\/pre>\n<\/p>\n
Conclusiones<\/h2>\n
En este artículo hemos aprendido lo siguiente:<\/p>\n