Operadores aritméticos

En este segundo post de la serie exploramos los operadores en Swift moderno. Son las herramientas que usarás en prácticamente cada línea de código: para calcular, comparar, combinar condiciones y manejar valores nulos. Algunos como el ?? son exclusivos de Swift y los usarás constantemente.

Operadores aritméticos

Los clásicos de siempre. Swift los soporta todos y se comportan exactamente como esperarías.

let suma       = 10 + 5   // 15
let resta      = 10 - 5   // 5
let producto   = 10 * 5   // 50
let division   = 10 / 3   // 3  (división entera, no 3.33)
let residuo    = 10 % 3   // 1  (el "sobrante" de la división)

// Con decimales la división sí da resultado decimal
let divDecimal = 10.0 / 3.0  // 3.3333...

El operador % (módulo o residuo) es muy útil para saber si un número es par o impar, o para ciclar índices en un arreglo.

// Truco clásico: par o impar
let numero = 7
if numero % 2 == 0 {
    print("Es par")
} else {
    print("Es impar")  // se imprime esto
}

Operadores de asignación compuesta

Combinan una operación aritmética con la asignación. Son un atajo muy común para modificar variables.

var puntos = 100

puntos += 25   // equivale a: puntos = puntos + 25  → 125
puntos -= 10   // equivale a: puntos = puntos - 10  → 115
puntos *= 2    // equivale a: puntos = puntos * 2   → 230
puntos /= 5    // equivale a: puntos = puntos / 5   → 46
puntos %= 10   // equivale a: puntos = puntos % 10  → 6

Operadores de comparación

Comparan dos valores y devuelven un Bool (true o false). Son la base de todas las condiciones en tu código.

let a = 10
let b = 20

print(a == b)   // false  — igual a
print(a != b)   // true   — distinto de
print(a <  b)   // true   — menor que
print(a >  b)   // false  — mayor que
print(a <= b)   // true   — menor o igual que
print(a >= b)   // false  — mayor o igual que

// También funcionan con Strings
let estado = "activo"
print(estado == "activo")   // true
print(estado != "inactivo") // true

Operadores lógicos

Combinan o invierten condiciones booleanas. Son esenciales para construir condiciones compuestas.

let usuarioActivo = true
let tieneSuscripcion = false

// AND — ambas condiciones deben ser true
if usuarioActivo && tieneSuscripcion {
    print("Acceso completo")
}

// OR — al menos una condición debe ser true
if usuarioActivo || tieneSuscripcion {
    print("Acceso parcial")  // se imprime esto
}

// NOT — invierte el valor booleano
if !tieneSuscripcion {
    print("Sin suscripción activa")  // se imprime esto
}

Operador ternario

Es una forma compacta de escribir un if/else en una sola línea. Muy útil cuando asignas un valor según una condición.

// Sintaxis: condición ? valorSiTrue : valorSiFalse
let edad = 20
let acceso = edad >= 18 ? "Permitido" : "Denegado"
print(acceso)  // "Permitido"

// Equivale a:
let accesoLargo: String
if edad >= 18 {
    accesoLargo = "Permitido"
} else {
    accesoLargo = "Denegado"
}

// En SwiftUI lo verás mucho para alternar entre valores
let temperatura = 35.0
let icono = temperatura > 30 ? "☀️" : "🌥️"

Úsalo con moderación — si la condición es compleja o el resultado requiere lógica extra, es mejor un if/else tradicional para mantener legibilidad.

Operadores de rango

Swift tiene dos operadores de rango que verás constantemente al trabajar con colecciones y bucles.

// Rango cerrado (...) — incluye ambos extremos
for i in 1...5 {
    print(i)  // 1, 2, 3, 4, 5
}

// Rango semiabierto (..<) — excluye el extremo superior
for i in 0..<5 {
    print(i)  // 0, 1, 2, 3, 4
}

// El rango semiabierto es ideal para iterar arrays (base 0)
let frutas = ["Manzana", "Pera", "Uva"]
for i in 0..<frutas.count {
    print("\(i): \(frutas[i])")
}

// Rangos en switch
let calificacion = 85
switch calificacion {
case 90...100: print("Excelente")
case 70..<90:  print("Aprobado")   // se imprime esto
case 0..<70:   print("Reprobado")
default:       print("Inválido")
}

Operador nil-coalescing ??

Este es uno de los operadores más característicos de Swift. Trabaja con opcionales (valores que pueden ser nil) y permite definir un valor por defecto cuando el opcional está vacío. Lo verás en casi cualquier proyecto real.

// Sintaxis: opcional ?? valorPorDefecto
let nombreUsuario: String? = nil
let nombre = nombreUsuario ?? "Invitado"
print(nombre)  // "Invitado"

let valorGuardado: String? = "Swift"
let resultado = valorGuardado ?? "Valor por defecto"
print(resultado)  // "Swift" — usa el valor real porque no es nil

// Caso práctico: leer de UserDefaults u otras fuentes opcionales
let idiomaGuardado: String? = nil
let idioma = idiomaGuardado ?? "es"
print(idioma)  // "es"

Los opcionales se explican en detalle en el Básico 04 de esta serie, pero es importante conocer ?? desde el principio porque lo encontrarás en casi todos los ejemplos de Swift.

Resumen

Aritméticos (+, -, *, /, %): operaciones matemáticas básicas.
Asignación compuesta (+=, -=…): modifican una variable y asignan en un paso.
Comparación (==, !=, <, >…): comparan valores, devuelven Bool.
Lógicos (&&, ||, !): combinan o invierten condiciones.
Ternario (? :): if/else compacto para asignación de valores.
Rango (…, ..<): definen intervalos, ideales en bucles y switch.
Nil-coalescing (??): valor por defecto cuando un opcional es nil.

En el siguiente post veremos Control de Flujo — if, switch, bucles y el poderoso guard que cambia la forma en que estructuras tu código.