Condicionales y Operadores - Resumen

Este es un pequeño resumen de las clases de la sección Condicionales y Operaciones Básicas. Aquí puedes encontrar código tal cual está escrito en las clases, y código que he cambiado para algunos ejemplos. Hay algunos links de referencia a la documentación de Swift para revisar los temas vistos en el curso de introducción a Swift del profesor Juan Gabriel. Si tienes algún comentario o sugerencia es bienvenido 😃

Operadores

Existen tres tipos de operadores:

1. Unarios
2. Binarios
3. Ternarios

• Asignación (Binario)

let b = 10
var a = 5
a = b

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

Recuerda que este operador significa: El valor de la derecha se asigna a la variable de la izquierda. Siempre.

Recuerda las formas correctas de declarar constantes y variables en Swift. Sección: Naming Constants and Variables.

The Basics - The Swift Programming Language (Swift 5.3)

• Comparación (binario)

if a == b
{
		print("El valor de a y b son iguales")
}

¿Es a igual a b? Sí o No

• Aritméticos (Binario)

1 + 2
5 - 3
2 * 3
10.0 / 2.5

Operadores aritméticos con números, similar a C/C++

Con strings:

"Hello " + "World"

Resultado: “Hello World”, similar a Java.

Operador módulo

9 % 4

El módulo funciona igual que en C/C++. Recuerda que solo se puede puede usar con números enteros. El resultado también solo será un entero. Para trabajar números de punto flotante, ve a la sección Truncating Remainder.

La definición de módulo es el residuo de la división entre dos números. Si la división es entera, el residuo será 0. Si no es entera habrá un sobrante: por ejemplo, 9 % 4 = 1. Para llegar a ello tenemos:

• Operación

• Aritmético (Unario)

let five = 5
let minusFive = -five

let minusSix = -6
let alsoMinusSix = +minusSix

El operador - en un número o una variable de tipo número le cambia el signo a este último.

El operador + le mantiene el mismo signo.

Aunque el + aparentemente no tendría utilidad, podemos usarlo con la sintaxis que también usa C o Java:

var number = 5

number += 3// Equivalente a number = number + 3
number -= 2// Equivalente a number = number - 2

Incrementar una variable en 3 y guardarla en la misma variable.

Puedes usar el resto de operaciones aritméticas:

number /= 2
number *= 12
number %= 7//number = number % 7

Truncating Remainder

Declaración de la función:

func truncatingRemainder(dividingBy other: [Double] -> [Double](https://developer.apple.com/documentation/swift/double)

Cumple la condición:

Con esta función obtienes t, el residuo. Equivale a lo que entre enteros es: a % c = t

Similar a la ecuación escrita más arriba con el ejemplo de 9 % 4 sólo que válida para números de punto flotante, tenemos:

// a = 12.5, b = 14.0, c = 0.85, t = 0.6
let a1 = 12.5
print(a1 / 0.85) // a/c = 14.70588... 

let b1 = (a1 / 0.85).rounded(.towardZero)// 14.0
let t = a1.truncatingRemainder(dividingBy: 0.85)// 0.6

let a2 = b1 * 0.85 + t // Comprobación a = b * c + t
print(a2) // 12.5

Si te fijas en este caso al obtener la parte entera de a/c, es decir truncando, estás obteniendo b al deshacerte del sumando t/c. Por tanto podrías obtener t despejando de la ecuación, y te dará lo mismo que la función truncatingRemainder:

let t = a1.truncatingRemainder(dividingBy: 0.85)// 0.6

var prueba = ( ( a1 / 0.85 ) - b1 ) * 0.85// t = ( a/c - b) * c
print(prueba) // 0.6

Por último fíjate que tal cual en la operación módulo con enteros, b es sólo la parte entera de la división a/c (como en 9/4 = 2) así estemos tratando con números double, dado que lo que falta de esta división es el residuo y es lo que queremos hallar. Es el mismo principio para ambos.

Comparaciones

Prueba este código en tu playground.

//Comparaciones
1 == 1
2 == 1
1 != 2
2 > 1
3 <= 5
2 <= 1

• Condicionales

let name = "Juan Gabriel"

if name == "Juan Gabriel"
{
    print("Bienvenido \(name)")
}else{
    print("Cuidado, ha aparecido \(name)")
}
//Output: "Bienvenido Juan Gabriel\n"

Comparación de tuplas:

(1, "Juan Gabriel") < (2, "Ricardo Celis") //true
(3, "Juan Gabriel") < (3, "Ricardo Celis") //true
(3, "Ricardo Celis") < (3, "Juan Gabriel") //false
(4, "perro") == (4, "perro") //true
//("perro", false) < ("perro", true) No tiene sentido por los booleanos
("perro", false) == ("perro", true) //false

Operador Ternario

let contentHigh = 40
var hashImage = true
var rowHeight = 0

// 1.
if hashImage
{
    rowHeight = contentHigh + 50
}else{
    rowHeight = contentHigh + 10
}

// 2.
rowHeight = contentHigh + (hashImage ? 50 : 10) 
//Si hashImage es true, el sumando es 50\. Si es false, es 10

Si te fijas para este caso en la manera tradicional if-else estás repitiendo la misma línea de código excepto un número constante diferente para cada caso. Con la segunda manera estás logrando lo mismo sin un if-else y una vez lo memorices será muy intuitivo de usar.

Nil Coalescing

let defaultAge = 18
var userAge: Int?

userAge = 31
var ageToBeUsed = userAge ?? defaultAge 
//Con ternario ageToBeUsed = (userAge != nil ? userAge! : defaultAge)

userAge es una variable optional. La edad que va a usar el código es userAge si existe. Sino defaultAge. El ejemplo comentado con el operador ternario era tan usado que decidieron implementar el Nil Coalescing.

Rangos

El operador de rango cerrado define un rango que va de a hasta b de la siguiente manera:

• Rango cerrado: 1…5
• Rango semiabierto: 1…<5
• Rango acotado por un sólo lado:
  • …5
  • 1…

//Ejemplos
for idx in1...5
{
    print(idx)
}

// 5 times

for idx in1..<5
{
    print(idx)
}

// 4 times

• Con arreglos:

let names = ["Ricardo", "Juan Gabriel", "Pedro"]

// 1.
for i in0..count
{
    print("La persona \(i + 1) se llama \(names[i])")
}

// 2.
for name in names {
    print(name)
}

// 3.
for name in names[1...] {
    print(name)
}

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

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

1. El primer ciclo recorre el arreglo utilizando su índice: names[i]. El ciclo for no recorre directamente el arreglo, sino que itera i desde 0 hasta n-1, dónde n es el tamaño del arreglo.
2. El segundo ciclo recorre directamente el arreglo. Declara una variable interna name que representa cada elemento del arreglo sin importar el tipo de dato.
3. En los últimos 3 casos se recorre directamente el arreglo pero teniendo en cuenta el rango.

Operadores lógicos

• NOT (!a)
• AND (a && b)
• OR (a || b)

Los operadores && y || se asocian desde la izquierda. Es decir que las expresiones compuestas se evalúan desde la sub-expresión que está más a la izquierda.

let hasMoney = false
let hasInvitation = true
let enterDoorCode = true
let passRetinaScan = false

if enterDoorCode && passRetinaScan || hasMoney || hasInvitation {
    print("Has entrado")
}else{
    print("Acceso denegado")
}

//Output: Has entrado

Recuerda que siempre puedes referirte a la documentación oficial de Swift. Los temas tratados en esta parte están la sección Basic Operators.