Archivo de la categoría: Swift

Recoger información desde el teclado desde un script en Swift en MacOS

Ya hemos visto en un artículo anterior cómo ejecutar un script en Swift. Pero no podemos alcanzar la máxima potencia de un script lanzado desde la terminal si no podemos pasarle parámetros.

Desde Swift podemos crear aplicaciones de línea de comandos usando xCode pero también podemos crear un simple script en Swift que recoja los parámetros que el usuario le vaya pasando mientras se ejecuta el script. Para ello podemos ir solicitando al usuario que introduzca texto a través de la terminal de MacOS.

En este artículo veremos un simple script que nos preguntará nuestro nombre para poder mostrar un saludo personalizado.

Creando el fichero de nuestro script

Desde la terminal crearemos el fichero saludame.swift.


echo "" >> saludame.swift

Editando el código de nuestro script

Primero debemos abrir nuestro fichero con un editor de código. Para ello desde la terminal usaremos el comando open.


open saludame.swift

El código para obtener la información introducida por el teclado se consigue con la función readLine(). El código completo de nuestro script sería el siguiente:


print("Introduce tu nombre:")
let nombre = readLine()
print("Hola \(nombre!)")

Ejecutando nuestro script

Desde la terminal debemos ejecutar el comando swift indicando el nombre de nuestro fichero de código.


swift saludame.swift

Al ejecutar el comando en la terminal nos pedirá nuestro nombre y tras introducirlo y pulsar la tecla Enter nos mostrará un mensaje de saludo con nuestro nombre.

Ejecutar scripts de Swift desde la terminal de MacOS

El lenguaje de programación Swift, creado por Apple, cada vez tiene más presencia en todas partes. Ahora incluso podemos ejecutar ficheros de código Swift desde la consola del sistema MacOS.

En este artículo realizaremos un pequeño ejemplo de script en Swift y lo ejecutaremos desde la consola. El script mostrará un texto de saludo en la consola.

Creando el fichero para nuestro script

En nuestra carpeta de trabajo crearemos un fichero llamado saludo.swift. Esto lo podemos hacer desde la propia terminal de MacOS.

En la terminal escribe el comando siguiente:


echo "" >> saludo.swift

Editando nuestro script

Para abrir el fichero en xCode y editar su código podemos usar xCode o la aplicación que el sistema operativo vea más apropiada. Para ello desde el terminal usaremos el comando open. Escribiremos en la terminal el siguiente comando:


open saludo.swift

Una vez abierto el entorno de xCode deberemos escribir el código para mostrar un texto de saludo por pantalla. El código sería el siguiente:


print("Hola mundo!")

Ejecutando el script en Swift

Una vez guardado el fichero con nuestro código podemos ejecutar el fichero Swift con el comando swift. En la terminal de MacOS debemos ejecutar el siguiente comando:


swift saludo.swift

Control de flujo de la aplicación usando estructuras condicionales en Swift

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.

La mayoría de estructuras condicionales cumplen esta estructura:

Si se cumple una condición
entonces haz algo

Esto en Swift se consigue con la sentencia if y su sintáxis es la siguiente:


if condicionVerdadera {
// Codigo a ejecutar si se cumple la condicion
}

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.

Veamos un ejemplo sencillo.


/*
Playground de ejemplo de condicionales
*/
let num1 = 23
let num2 = 33

if num1 < num2 { print("Num1 es menor que num2") } if num1 > num2 {
print("Num1 es mayor que num2")
}
if num1 == num2 {
print("Num1 es igual que num2")
}

Comparaciones en Swift

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:

==
Igual a
!=
distinto de
<
Menor que
>
mayor que
<=
Menor o igual que
>=
mayor o igual que

Con este conjunto de comparaciones podemos resolver la mayoría de progremas de cualquier aplicación.

Ámbitos en Swift

En Swift el uso de las llaves ({ }) se utiliza para agrupar un trozo de código que pertenecerá a un mismo ámbito.

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.

Veamos esto en un ejemplo de código.


/*
Playground de ejemplo de ambitos en Swift
*/

let numFuera = 3
do {
let numDentro = 5
print("fuera= \(numFuera) dentro = \(numDentro)")
}
print("fuera= \(numFuera) dentro = \(numDentro)")

Si intentamos ejecutar el código anterior obtendremos el siguiente error:

Playground execution failed:

error: PlayGroundTest.playground:4:38: error: use of unresolved identifier 'numDentro'
print("fuera= \(numFuera) dentro = \(numDentro)")
                                     ^~~~~~~~~

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 que está declarada dentro de un ámbito y esa función print() está siendo ejecutada fuera de ese ámbito.

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.

Encadenando y anidando condicionales

Relacionada con la sentencia if tenemos la sentencia else que nos permite ejecutar un bloque de código si no se cumple la condición que estamos evaluando. Sería algo como:

Si se cumple una condición
  entonces haz algo
Si no 
  entonces haz otra cosa

Con la sintáxis de Swift el ejemplo sería el siguiente:


if condicionVerdadera {
// Codigo a ejecutar si se cumple la condicion
} else {
// Codigo a ejecutar si no se cumple la condicion
}

Un ejemplo práctico podría ser este:


/*
Playground de ejemplo de condicionales
*/
let num1 = 23
let num2 = 33

if num1 < num2 { print("Num1 es menor que num2") } else { print("Num1 no es menor que num2") }

Podemos encadenar varios else if para optimizar nuestro código. Nuestro ejemplo inicial quedaría de la siguiente forma:


/*
Playground de ejemplo de condicionales
*/
let num1 = 23
let num2 = 33

if num1 < num2 { print("Num1 es menor que num2") } else if num1 > num2 {
print("Num1 es mayor que num2")
}
else if num1 == num2 {
print("Num1 es igual que num2")
}

Además dentro de un dominio de una condición podemos incluir nuevas condiciones creando condiciones anidadas. Veamos un ejemplo práctico


/*
Playground de ejemplo de condicionales
*/
let num1 = 23
let num2 = 33

if num1 < num2 { if num1 == 23 { print("Num1 es menor que num2 y num1 tiene el valor 23") } else { print("Num1 es menor que num2") } } else { print("Num1 no es menor que num2") }

Realizando varias comparaciones a la vez

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.

Para poder crear estas uniones entre comparaciones tenemos las palabras AND y OR qe nos permiten crearr combinaciones más complejas. Pero en Swift en lugar de utilizar la palabra AND debemos usar el doble símbolo de ampersand (&&) y para la palabra OR debemos usar el doble símbolo de línea vertical (||).

Si utilizamos el AND indicamos que ambas comparaciones deben cumplirse para que la condición sea verdadera. Pero si utilizamos el OR sólo necesitamos que se cumpla una de las comparaciones para considerar que la condición se cumple.

Veamos un ejemplo de código


/*
Playground de ejemplo de condiciones compuestas
*/

let num1 = 10
let num2 = 20
var num3 = num2 / num1
var num4 = 2

if num1 < num2 && num3 == num4 { print("num1 es menor que num2 y num3 es igual que num4") } else { print("No se cumple la condición de num1 es menor que num2 y num3 es igual que num4") } // cambiamos el valor de num4 num4 = 4 if num1 < num2 && num3 == num4 { print("num1 es menor que num2 y num3 es igual que num4") } else { print("No se cumple la condición de num1 es menor que num2 y num3 es igual que num4") } // Cambiamos and por or if num1 < num2 || num3 == num4 { print("num1 es menor que num2 o num3 es igual que num4") } else { print("No se cumple la condición de num1 es menor que num2 o num3 es igual que num4") }

Al ejecutar este código obtendremos este resultado:

num1 es menor que num2 y num3 es igual que num4
No se cumple la condición de num1 es menor que num2 y num3 es igual que num4
num1 es menor que num2 o num3 es igual que num4

Conclusiones

En este artículo hemos aprendido lo siguiente:

  • Qué es un control de flujo
  • Qué es un ámbito en Swift
  • Cómo podemos comparar variables y valores
  • Cómo anidar y encadenar controles de flujo

El uso de los bloques de control de flujo son indispensables para poder crear aplicaciones que hagan algo más que mostrar valores por pantalla por lo que es muy importante dominar bien este aspecto de la programación.

Comentarios en Swift

Cuanto más conocemos Swift más complicado se vuelven nuestros Playgrounds. Es necesario ir incluyendo anotaciones o aclaraciones en nuestro código. Veamos el siguiente ejemplo.


let num1 = 54
let num2 = 235
var resultado = 0

// Almacenamos la multiplicacion de num1 y num2 en rsultado
resultado = num1 * num2
// y lo mostramos por consola
print("El resultado de \(num1) * \(num2) es \(resultado)")

El ejemplo mostrará el siguiente resultado:

El resultado de 54 * 235 es 12690

En el código anterior hemos encontrado unas líneas de código que comienzan por dos barras inclinadas (//) esto indica que todo lo que haya a la derecha de esas dos barras inclinadas es un comentario para ayudar a comprender mejor el código.

Los programadores usamos los comentarios para multitud de funciones: describir que hace o va a hacer un trozo de código, incluir un Copyright o copyleft en el código, añadir marcas o secciones en el fichero de código para marcar zonas y movernos más rápido por un fichero de código grande, etc.

Con las dos barras inclinadas (//) sólo podemos comentar una línea de código pero en Swift podemos comentar un bloque de líneas de código si las encerramos entre los símbolos /* y */. Veamos este código de ejemplo.


/*
Playground de pruebas
w≤ww.programaraciegas.net

(Copyleft) Tyflos Accessible Software 2017
*/

// Escribimos un saludo
print("Hola mundo!")

Si ejecutamos el código anterior en un Playground se ignorarán todas las líneas de comentario y sólo se ejecutará la función print().

Conclusiones

Es muy recomendable utilizar comentarios en nuestro código tanto para nosotros mismos por si visitamos nuestro código tras mucho tiempo o por si lo compartimos con otros desarrolladores.

También podemos utilizar los comentarios para desactivar o activar zonas de código que estemos probando.

Por estas y otras razones es muy necesario que tengamos el hábito de comentar nuestro código y saber utilizar las diversas formas de incluir comentarios en nuestro código.

Variables en Swift

A la hora de crear un programa o aplicación informática necesitamos poder almacenar, manipular, comparar y actualizar información. Para todas estas operaciones los lenguajes de programación utilizan un elemento conocido como variable. Una variable es una porción de memoria donde el programa almacena un valor indicado por el programador.

Las variables poseen un nombre con el que identificarlas y un tipo. El tipo define qué clase de información podrá almacenar la variable. A modo de ejemplo, imaginemos que tenemos diversos productos: agua, zapatos y naranjas y tenemos varios tipos de contenedores: caja de cartón, bolsa de plástico y botella de cristal. Cada contenedor es idóneo para un tipo de elemento concreto y podría ser perjudicial si introdujésemos un elemento en un contenedor no apropiado como meter agua en la caja de cartón o en la bolsa de plástico con algún posible agujero.

Declarando variables en Swift

En Swift, al igual que otros muchos lenguajes de programación necesitamos declarar las variables que vamos a utilizar para que el sistema pueda preparar la memoria del ordenador para almacenar la información que va a contener la variable. La forma de declarar una variable en Swift es utilizando la palabra var. La sintaxis completa es:

var nombreDeVariable : tipo = valorInicial

Ese valor inicial es obligatorio a menos que hagamos que nuestra variable sea de tipo opcional pero los tipos opcionales implican un concepto un poco complejo que se explicará más adelante en otros artículos donde tratemos con clases, objetos e instancias.

El tipo de la variable indica qué clase de información va a almacenar dicha variable: texto, números decimales, números enteros, un botón de nuestra interfaz, el dato de un contacto de nuestra agenda o un tipo que hayamos creado nosotros mismos.

Los tipos básicos en Swift son los siguientes:

String
Cadena de texto
Int
Número entero
Float
Número decimal
Double
Número decimal con más de 6 decimales
Bool
Valor booleano que almacena verdadero o falso

En Swift podemos dejar que el propio lenguaje deduzca el tipo de la variable, es lo que se denomina inferencia. Esto lo podemos hacer al declarar la variable y asignarle un valor sin indicar su tipo.

var miNombre = "Fulano de tal"

Una vez definido el tipo de una variable no podemos cambiar su tipo posteriormente por lo que hay que tener esto en cuenta a la hora de manipular las variables para cambiar sus valores.

Constantes en Swift

Una constante en programación es una variable que una vez declarada con su valor dicho valor no cambia en ningún momento. Ejemplos como el valor del número PI, la aceleración de la gravedad en la Tierra o el número máximo del nivel de vida del personaje jugador del juego que estamos programando son ejemplos de constantes en Swift.

Para declarar una constante se utiliza la palabra let y la sintaxis es la misma que para una variable.

let nombreDeConstante : tipo = valorParaLaConstante

También podemos utilizar la inferencia a la hora de declarar una constante.

let aceleracionGravedad = 9.8

En Swift, como en otros muchos lenguajes de programación el símbolo de coma numérica se indica con el signo . (punto) esto tanto para Float como Double como otros posibles tipos de números decimales

Utilizando variables

Una vez hemos declarado la variable podemos operar con ella simplemente nombrándola y realizando operaciones con ella. Por ejemplo:

Cambiando su valor:


var miVariable = 3
miVariable = 5

Combinando matematicamente varias variables:


var num1 = 3
var num 2 = 5
var num 3 = num1 + num2

Modificando una variable a partir de su valor anterior


var num1 = 5
num1 = num1 + 100

Visualizando el valor de una variable

Ya vimos en el artículo de primeros pasos con Swift el comando print. Por ahora utilizaremos dicho comando para ir viendo los diferentes valores de las variables en nuestros ejemplos.

La función print() nos permite mostrar una cadena de texto por la consola de depuración de xCode. Su sintaxis es muy sencilla:

print(variableDeTextoParaMostrar)

Ahora sólo debemos conocer cómo poder incluir en una variable de texto el valor de otras variables. La forma es muy sencilla. Recordemos que para poder declarar una cadena de texto debemos encerrar el valor de texto de nuestra variable entre los símbolos de dobles comillas ("). por ejemplo:


var miTexto = "Esto es un texto de prueba"
print(miTexto)

Si en nuestro Playground escribiesemos el código anterior obtendríamos el siguiente resultado por la consola de depuración:

Esto es un texto de prueba

Para incluir el valor de una variable dentro de una cadena de texto debemos utilizar una secuencia de escape que permita a xCode conocer nuestra intención de insertar en una posición concreta de la cadena de texto el valor de una variable. Esa secuencia de escape consiste en escribir barra invertida seguida de abre paréntesis y cierra paréntesis (\()). Por ejemplo, veamos el siguiente código:


var numero = 33
var texto = "Diga \(numero)"
print(texto)

Ejercicio de manipulación de variables

Vamos a poner en prática los conocimientos aprendidos hasta ahora y vamos a escribir un código en nuestro Playground que realice las siguientes operaciones:

  • Declarar 3 constantes con 3 valores numéricos distintos
  • Declarar una variable numérica para almacenar el resultado de las distintas operaciones
  • Sumar las dos primeras constantes y mostrar el resultado por consola
  • Al resultado anterior restarle la tercera constante y mostrarlo por consola
  • Al resultado anterior multiplicarlo por 100

Es muy recomendable que antes de ver la solución propuesta intentéis crear vuestro propio código.

La solución propuesta es la siguiente:


let num1 : Int = 3
let num2 : Int = 5
let num3 : Int = 6
var resultado = 0

resultado = num1 + num2
print("Operación 1 = \(resultado)")
resultado = num1 + num2 - num3
print("Operación 2 = \(resultado)")
resultado = resultado * 100
print("Operación 3 = \(resultado)")

El resultado que saldrá por consola será:

Operación 1 = 8
Operación 2 = 2
Operación 3 = 200

Si os fijáis para las constantes si hemos indicado el tipo pero para la variable de resultado hemos utilizado la inferencia.

Conclusiones

En este artículo hemos visto:

  • Cómo hacen las aplicaciones para almacenar y manipular información
  • Los requisitos de tipo a la hora de manipular información con variables
  • Las diferencias entre variables y constantes
  • Realizar operaciones matemáticas y almacenar los resultados
  • Introducir el valor de una variable dentro de una cadena de texto
  • Usar la función print() para algo más que saludar

Es necesario familiarizarse con el uso de variables en Swift si queremos progresar en este lenguaje de programación por lo que es muy recomendable que hagáis vuestros propios experimentos y recordad que dentro de un Playground no se romperá nada en tu ordenador por lo que podéis hacer todas las pruebas que queráis.

Primeros pasos con Swift

Swift es un nuevo lenguaje de programación creado por Apple buscando atraer a nuevos desarrolladores. La propia compañía lo describe en su página oficial de Swift como un lenguaje potente y sencillo de aprender.

Realmente Swift, en comparación con otros lenguajes, tiene una curva de aprendizaje menor y las herramientas proporcionadas por Apple para desarrollar con él lo hacen un lenguaje muy apropiado como primera opción para aprender a programar.

Recientemente Apple ha decidido donar su lenguaje a la comunidad de código abierto lo que permitirá a Swift estar presente en otras plataformas por lo que desarrollar una aplicación para iOS, OSX, Linux y otras plataformas será algo habitual en Swift.

Programando en Swift

Para programar en un lenguaje de programación lo primero que necesitamos son herramientas de desarrollo compatibles con ese lenguaje. Si somos usuarios del sistema operativo MacOS X sólo debemos ir a la aplicación de la Mac AppStore y descargar el entorno de desarrollo de Apple más conocido como xCode.

xCode, como otras aplicaciones específicas para una profesión, no es una herramienta sencilla de comprender con un primer vistazo pero tampoco es una tarea imposible. Iremos conociendo poco a poco esta herramienta junto con el aprendizaje de Swift en una serie de artículos publicados en este blog.

Para programar en otra plataforma distinta a MacOS X hay varias alternativas proporcionadas por la comunidad de código abierto de Swift los cuales trabajan en un compilador para varias plataformas. Actualmente el compilador funciona para el sistema operativo Linux.

Otra alternativa para ir practicando con Swift mientras aprendemos es utilizar una herramienta online creada por IBM para este objetivo. Esta herramienta es conocida como IBM Swift Sandbox y nos ofrece la posibilidad de crear y ejecutar un Playground de Swift a través de nuestro navegador web. Esta herramienta web, aunque recientemente ha solucionado algunos problemas de compatibilidad con dispositivos móviles para poder programar en cualquier momento desde cualquier lugar, presenta algunas barreras de accesibilidad relacionadas con el uso de esta herramienta por parte de usuarios de productos de apoyo por lo que se recomienda utilizar en su lugar xCode o el compilador de Swift para Linux. Esperemos que pronto esté disponible este compilador para otros sistemas operativos.

¿Qué es un Playground de Swift?

Con la creación de Swift Apple también desarrolló nuevas herramientas y conceptos que ayuden a los desarrolladores a realizar su trabajo con mayor efectividad. Una de sus creaciones es el Playground de Swift. Un Playground de Swift es un mini proyecto de aplicación que nos permite probar de forma rápida y controlada partes de código antes de que decidamos introducir ese nuevo código en nuestro proyecto de trabajo. Esto permite probar algoritmos y funciones de una forma cómoda, segura y, además, Apple ha incorporado herramientas de monitorización en los Playgrounds para obtener el rendimiento de los algoritmos ejecutados así como permitir hacer una depuración más intensa de nuestro código.

Nuestro primer programa en Swift

Supongamos que vamos a utilizar xCode para crear nuestro primer programa en Swift. Al abrir xCode aparecerá una ventana de bienvenida. En ella habrá diversos botones, entre ellos encontramos uno que nos permite empezar con un Playground de Swift de forma rápida, es el botón con el título Get started with a playground. Una vez pulsado nos pedirá que demos un nombre a nuestro fichero de Playground y seleccionar una de las plataformas para nuestro Playground: iOS, OSX o TVOS. Tras esto se nos consultará dónde guardar el fichero de nuestro Playground. Con esto xCode ya puede crear el entorno de desarrollo para que empecemos a jugar con nuestro Playground de Swift.

xCode presenta en su interfaz un area de menú con una barra de herramientas con las principales opciones de ejecución, depuración y visualización, y un area de trabajo. Los usuarios de VoiceOver pueden identificar estas zonas fácilmente si utilizan el gesto de dejar de interactuar con el item varias veces (VO+Mayúsculas+flecha arriba). Explorando la ventana desde arriba a la izquierda siguiendo la exploración hacia la derecha encontrará la barra de herramientas, identificada como Toolbar, una zona para controlar las pestañas abiertas en xcode y un area de trabajo. Este area de trabajo es identificada por VoiceOver con el título de ruta de nuestro proyecto, sería algo parecido a MyPlayground.playground split group. Interactuando con el area de trabajo encontraremos varios subcontenedores:
el editor de código, la barra de debug, la zona de debug y varias zonas relacionadas con el diseño visual de la interfaz. Esta zona puede que contenga todos, algunos o ningunos de estos subcontenedores ya que podemos modificar la visualización de xCode en las opciones del menú View de la barra de menú de xCode. Por ahora sólo nos interesa el subcontenedor donde se encuentra el editor de código, VoiceOver lo identificará con el nombre de nuestro fichero en edición; la barra de debug y el panel de debug o depuración, dentro de este panel encontraremos la opción de ejecución para nuestro Playground.

En el editor de código encontramos que ya hay escrito un código de ejemplo:


//: Playground - noun: a place where people can play
import Cocoa
var str = "Hello, playground"

Prueba a borrar todo ese código, escribir el siguiente código y pulsar el botón Execute que hay en la barra de debu:


print("Hola mundo!")

Tras ejecutar el código veremos que el texto Hola mundo! aparece en el area de depuración. ¡Enhorabuena, has creado tu primer programa en Swift!

Puede que sólo encuentres la barra de debug, identificada por VoiceOver como debug bar group y no encuentres el panel de debug, identificado por voiceOver como debug group. Esto puede suceder porque este panel de depuración se puede ocultar. Para hacer que se vea podemos entrar en la barra de debug y pulsar el botón show debug area o usar la opción de la barra de menú de xCode en el menú View o el atajo de teclado ()Comando+Mayúsculas+Y).

Un primer paso de otros muchos

Pensaréis que este programa no vale para nada pero si habéis seguido las instrucciones hasta aquí se supone que habéis adquirido los primeros conocimientos para comenzar a aprender Swift ya que ahora sabéis lo siguiente:

  • Saber escribir código y ejecutar código en un Playground
  • Usar la función print() que muestra un texto por pantalla

En futuros artículos iremos aprendiendo más cosas sobre este lenguaje de programación.