Swift – Operadores

Hoy aprenderemos sobre los operadores que tenemos a nuestra disposición: los operadores lógicos, los operadores relacionales, los operadores aritméticos, etc.

Por más trivial que suene siempre es bueno conocer esos matices que todo lenguaje tiene y que en muchas ocaciones los diferencia.

[better-ads type=’banner’ banner=’159′ ]

No quiero verme inmerso en algo tan aburrido como explicar el uso del operador + (suma) el cual asumo ya todos conozcan. Así que nos enfocaremos en aspectos más importantes / prácticos de los operadores en el lenguaje de programación Swift.

Operador de Asignación

El operador es posiblemente de los más conocidos y por ende más sencillos de explicar:

let number = 10

var otherNumber = number

y es que es sencillamente eso, es el operador (=) mediante el cual informamos al compilador que cierta posición de memoria asociada a una constante o variable le asignaremos cierto valor literal o el que almacena una constante como en el ejemplo anterior.

Operadores Aritméticos

Los operadores aritméticos son ese otro grupo que todos conocemos a través de las clases de matemáticas y que en la programación también usamos para expresar operaciones:

let radius: Double = 8.5

let area = Double.pi * (radius * radius)

print("El área del circulo es de (String(format: "%.2f", area)) unidades.")

En este ejemplo calculamos el área de una circunsferencia cuyo radio es de 8.5 unidades. Nos hemos apoyamos en la constante pi ya definida por Swift dentro del tipo de dato Double.

[better-ads type=’banner’ banner=’160′ ]

Hemos seguido la formula para calcular el área de una circunsferencia (a = π * r²), almacenamos el resultado en la constante area. Luego lo imprimimos en pantalla mediante la función print.

En este código hemos utilizado el operador de asignación (=) y el de multiplicación (*), ambos idénticos a los que utilizamos en la vida real para plantear este tipo de operaciones.

Nota: Espero que no se sientan intimidados por el código anterior, sobre todo por el tema de la función print que quizás algunos no entiendan. Todo esto lo vamos a ir viendo poco a poco, aquí solo hemos expuesto un pequeño spoiler de todo lo que nos espera en futuros artículos.

La salida en pantalla sería:

El área del circulo es de 226.98 unidades.

Los operadores aritméticos disponibles en Swift son:

Operadores Relacionales

Los operadores relacionales o de comparación son aquellos que nos sirven a la hora de comparar si un número es mayor o menor que otro, si es mayor o igual o menor o igual, si es igual o desigual que otro valor e incluso podemos verificar si dos instancias de una misma clase son iguales o diferentes:

Los operadores relacionales también son considerados operadores lógicos, en este artículo los hemos separado con el único objetivo de segmentar las funcionalidades y queden así más claras las diferencias.

Operadores Lógicos

Las operaciones de Álgebra de Boole se efectúan también mediante los operadores lógicos siguientes:

Con el operador NOT podemos crear expresiones simples como:

import UIKit

let someValue = 2

func lessThanFive(_ value: Int) -> Bool {
    
    return value < 5
    
} // lessThanFive

print("¿El valor \(someValue) es menor que cinco? Respuesta: \(lessThanFive(someValue))")

print("¿El valor \(someValue) es menor que cinco? Respuesta: \(!lessThanFive(someValue))")

En las últimas dos líneas reside el enfoque del ejemplo, en la línea 12 imprimimos un texto en pantalla donde nos preguntamos si un valor es menos que cinco, pasamos ese valor como parámetro a la función que hemos declarado de la línea 6 a la 10 y de nombre lessThanFive.

Esta función la primera ves que la ejecutamos pues devuelve verdadero ya que en efecto 2 es menor que cinco o lo que sería lo mismo la expresión 2 < 5 es igual a true. Similar sucede con la línea 14 pero con la diferencia de que hemos usado el operador binario NOT sobre el resultado que nos devuelve la función, obteniendo el resultado inverso:

¿El valor 2 es menor que cinco? Respuesta: true
¿El valor 2 es menor que cinco? Respuesta: false

Ahora, en el caso de los operadores lógicos AND y OR en conjunción con los operadores relacionales podemos lograr expresiones más complejas donde evaluar más de una expresión a la vez. Veamos:

import UIKit

let someValue = 2

func lessThanFive(_ value: Int) -> Bool {
    
    return value < 5
    
} // lessThanFive

if someValue > 0 && someValue < 10 && lessThanFive(someValue) {
    
    print("El valor \(someValue) se encuentra entre 0 y 10 y es menor que cinco")
    
} // if

if someValue > 0 && lessThanFive(someValue) {
    
    print("El valor \(someValue) es mayor que cero y menor que 5.")
    
} // if

if someValue > 10 || lessThanFive(someValue) {
    
    print("El valor \(someValue) es o mayor que 10 o menor que 5.")
    
} // if

En las líneas 11, 17 y 23 hemos anidado varias expresiones en pos de lograr filtrar ciertos valores, la salida en pantalla:

El valor 2 se encuentra entre 0 y 10 y es menor que cinco
El valor 2 es mayor que cero y menor que 5.
El valor 2 es o mayor que 10 o menor que 5.

explica por si misma la lógica que estamos persiguiendo en nuestro código.

Operador Ternario

Aparte de estos tenemos también el operador ternario que por alguna razón que no entiendo muchas personas lo obvian y usan if-else en sentencias tan simples como la del siguiente ejemplo, sentencia donde sin dudas el operador ternario es una opción que más que elegante parece que fue pensada para ella:

//: Playground - noun: a place where people can play

import Cocoa

var name = "Josh"
var totalPoints = 2

var message = totalPoints <= 2 ? "disapproved the exam." : "approved the exam."

print("The student \(name) has \(message)")

la salida en pantalla sería:

The student Josh has disapproved the exam.

Luego de analizar el ejemplo podemos deducir que la sintaxis de este operador ternario sería:

<expresión de control> ? < verdadero> : <falso>

la expresión de control es aquella que evaluaremos y en dependencia del resultado pues se ejecutará el primer bloque en caso de ser verdadera la expresión y el segundo en caso de ser falsa.

Operadores de Rango

Swift incluye varios operadores de rango, que no son más que accesos directos para expresar un rango de valores.

Operador de Rango Cerrado

El operador de rango cerrado (a … b) define un rango que va desde a hasta b, e incluye los valores a y b. El valor de a no debe ser mayor que b.

El operador de rango cerrado es útil cuando se realiza una iteración sobre un rango en el que desea utilizar todos los valores, como en un bucle for-in:

for index in 1...5 {
    
    print("\(index) multiplicado por 5 es \(index * 5)")

}

La sentencia for la explicaremos en un próximos artículos. Por el momento veámoslo como algo tan básico como un bloque que nos permite iterar n veces ejecutando el bloque de código dentro de las llaves.

Operador de Rango Semiabierto

El operador de rango medio abierto (a .. <b) define un rango que se extiende de a hasta b, pero no incluye b. De ahí viene su nombre, se le llama rango semiabierto porque contiene su primer valor, pero no su valor final.

Al igual que con el operador de rango cerrado, el valor de a no debe ser mayor que b. Dicho esto, si el valor de a es igual a b, pues básicamente no existe rango alguno y por ende «el rango» resultante estará vacío.

Los rangos semiabiertos son particularmente útiles cuando se trabaja con listas basadas en cero (que comienzan por cero), como en los arreglos de datos, donde es útil contar hasta (pero sin incluir) la longitud de la lista:

let names = ["Anna", "Alex", "Brian", "Jack"]

let count = names.count

for index in 0..<count {
    
    print("La persona número \(index + 1) se llama \(names[index])")

}

La salida en pantalla sería:

La persona número 1 se llama Anna
La persona número 2 se llama Alex
La persona número 3 se llama Brian
La persona número 4 se llama Jack

Tenga en cuenta que el arreglo (names) contiene cuatro elementos, pero 0..<count solo cuenta hasta 3 (el índice del último elemento del arreglo), porque es un rango medio abierto y el último elemento no se incluye.

El tema de los arreglos y otras estructuras de datos se verán en un próximo artículo.

Operador de Rango Unilateral

El operador de rango cerrado tiene una forma alternativa para los rangos que continúan lo más lejos posible en una dirección, por ejemplo, un rango que incluye todos los elementos de un arreglo desde el índice 2 hasta el último elemento.

En estos casos, puede omitirse el valor de un lado del operador de rango. Este tipo de rango se denomina rango de un solo lado o unilaterales porque el operador tiene un valor en un solo lado. Por ejemplo:

let names = ["Anna", "Alex", "Brian", "Jack"]

print("Nombres a partir del segundo elemento:")

for name in names[2...] {
    
    print(name)
    
}

print("\nNombres hasta el segundo elemento:")

for name in names[...2] {
    
    print(name)
    
}

La salida en pantalla sería:

Nombres a partir del segundo elemento:
Brian
Jack

Nombres hasta el segundo elemento:
Anna
Alex
Brian

El operador de rango medio abierto también tiene una forma unilateral escrita con solo su valor final. Al igual que cuando se incluye un valor en ambos lados, el valor final no es parte del rango. Por ejemplo:

let names = ["Anna", "Alex", "Brian", "Jack"]

print("Nombres hasta el segundo elemento sin incluirlo:")

for name in names[..<2] {
    
    print(name)

}

La salida en pantalla:

Nombres hasta el segundo elemento sin incluirlo:
Anna
Alex

Los rangos unilaterales se pueden usar en otros contextos, no solo en subíndices. También podemos verificar si un rango unilaterales contiene un valor particular, como se muestra en el siguiente código:

let range = ...5

range.contains(7)   // false
range.contains(4)   // true
range.contains(-1)  // true

Operador de Desbordamiento

Este tema fue lo que motivo este tutorial, el operador de desbordamiento. Este viene a ayudarnos con las operaciones matemáticas que predeciblemente pudieran generar un overflow (desbordamiento de memoria). Sí, ya se que quizás me estarán reclamando que esto lo podemos controlar con una simple validación de datos.

[better-ads type=’banner’ banner=’161′ ]

Bueno, ciertamente es así y de hecho quizás esta sea la razón por lo que es tan poco conocido. No obstante creo que como forma parte del lenguaje y no sabemos si en algún momento nos encontramos con situaciones donde una validación no es viable, puede que este operador nos salve el día, aquí tienen un ejemplo:

let y: Int8 = 120

let z = y + 10

creen que estas líneas son correctas? Pues la primera sí, pero la segunda genera un error y el motivo es el siguiente: La variable y es de tipo Int8 por lo que el compilador asume que la expresión y + 10 debe de ser Int8, esto a su vez deviene en inferir que el tipo de z es Int8 también

El problema reside en que el resultado sería 130 y el tipo de dato Int8 solamente puede almacenar valor en el rango de -128 a 127, lógicamente 130 excede el valor máximo positivo que la variable z puede aceptar.

Una posible solución sería hacer uso del operador de desbordamiento y en especifico aquel acorde a la operación matemática qe estemos efectuando, en este caso sería &+, si fuera una resta pues &-, una multiplicación &* y así. El ejemplo anterior quedaría:

let y: Int8 = 120

let z = y &+ 10

y el resultado almacenado en z sería -126 ya que el compilador de Swift al darse cuenta de que el número se pasa de 127, en este ejemplo por tres unidades, cuando el valor sobrepasa por una unidad se conmuta la suma al número negativo más pequeño y que es -128 y a partir de aquí se le siguen sumando el resto de unidades que en este punto solamente quedarían dos y -128 + 2 = -126.

De manera similar funcionaría con una resta y el operador &-, veamos el siguiente ejemplo:

let y: Int8 = -120

let z = y &- 10

aquí el valor de z es 126 positivo, la resta ha excedido  el valor mínimo de -128 en dos unidades ya que el resultado aritmético sería -130, entonces:

-130 – (-128) = -130 + 128 = -2

la primera de estas unidades restantes activa el overflow y para que el programa no se detenga pues el operador de desbordamiento conmuta la resta al número máximo positivo que es 127, en este punto ya solamente quedaría una unidad restante por lo que 127 – 1 = 126.

Para finalizar y a modo de aclaración, en la línea de más arriba donde expongo la sintaxis del operador ternario, la he encerrado entre <> debido a que cada uno de esos campos son mandatory (obligatorios), en caso de ser opcionales hubiera usado [], este estándar será el usado por defecto.

Falta aún mucho por aprender en nuestro camino a convertirnos en iOS Developer. Suscríbete a nuestra lista de correo y síguenos en nuestras redes sociales. Mantente al tanto de todas nuestras publicaciones.

Espero que todo cuanto se ha dicho aquí, de una forma u otra le haya servido de aprendizaje, de referencia, que haya valido su preciado tiempo.

Este artículo, al igual que el resto, será revisado con cierta frecuencia en pos de mantener un contenido de calidad y actualizado.

¡Cualquier duda o sugerencia, ya sea errores a corregir o ejemplos a añadir, será más que bienvenida, necesaria!