¿Cómo funcionan los tipos de datos y los opcionales en Swift?

Swift es un lenguaje con tipado estricto: cada valor que usas en tu app tiene un tipo definido, y Swift no permite mezclarlos sin conversión explícita.

En la lección anterior viste var y let. Ahora profundizarás en qué tipos de datos existen y aprenderás el concepto más importante de Swift para evitar errores: los opcionales.

Los cuatro tipos de datos esenciales

Swift tiene muchos tipos, pero en una app básica para iPhone usarás principalmente cuatro.

Cada tipo tiene un propósito claro. No uses Double para contar artículos ni Int para precios con centavos.

Declaración explícita de tipos

En la lección 3 viste que Swift infiere el tipo cuando asignas un valor de inmediato. Pero también puedes declararlo explícitamente.

Sintaxis:

var nombreVariable: Tipo = valor
let nombreConstante: Tipo = valor

Ejemplos:

var precioProducto: Double = 349.50
let nombreTienda: String = "Liverpool"
var articulosEnCarrito: Int = 3
var envioGratis: Bool = false

Declarar el tipo explícitamente es útil cuando el valor inicial no deja claro qué tipo esperas. Por ejemplo, escribir var calificacion: Double = 0 le dice a Swift que esperarás decimales después.

Operaciones entre tipos del mismo tipo

Swift no mezcla tipos automáticamente. Si intentas sumar un Int con un Double, el compilador marca error.

Ejemplo correcto:

let precioBase: Double = 1200.00
let descuento: Double = 150.00
let precioFinal: Double = precioBase - descuento
// precioFinal = 1050.0

Ejemplo incorrecto (genera error de compilación):

let precio: Double = 1200.00
let unidades: Int = 3
// let total = precio * unidades  // ❌ Error: no puedes multiplicar Double e Int directamente

Solución: conversión explícita de tipos

let precio: Double = 1200.00
let unidades: Int = 3
let total: Double = precio * Double(unidades)  // ✅ Correcto
// total = 3600.0

Esta regla parece estricta, pero te protege de errores sutiles que en otros lenguajes solo aparecen en tiempo de ejecución.

¿Qué es un opcional en Swift?

Un opcional (Optional) es un tipo que puede contener un valor o puede estar vacío (nil).

En el mundo real, muchos datos pueden no existir. Por ejemplo, un usuario de Mercado Libre puede o no tener un cupón de descuento registrado. Un cliente de FEMSA puede o no tener un RFC capturado en su perfil.

Swift representa esa ausencia de valor con nil. Pero para usar nil, debes declarar la variable como opcional usando ? después del tipo.

Sintaxis:

var nombreVariable: Tipo? = valor   // puede tener valor o ser nil
var otraVariable: Tipo? = nil       // empieza vacía

Ejemplos:

var cuponDescuento: String? = nil          // el usuario no tiene cupón todavía
var rfcCliente: String? = "XAXX010101000" // este cliente sí lo capturó
var calificacionReseña: Int? = nil         // la reseña aún no tiene calificación

Una variable no opcional (String, Int, etc.) nunca puede ser nil. Eso es lo que hace a Swift seguro: si tu variable no es opcional, Swift garantiza que siempre tendrá un valor.

Cómo usar el valor de un opcional: el "desenvoltorio"

Un opcional no se puede usar directamente como si fuera un valor normal. Debes desenvolverlo (unwrap) primero.

Swift ofrece varias formas de hacerlo.

1. Desenvoltorio opcional con if let

Esta es la forma más segura y recomendada para principiantes.

var cuponDescuento: String? = "BUEN FIN 2024"

if let cupon = cuponDescuento {
    print("Tu cupón activo es: \(cupon)")
} else {
    print("No tienes cupón activo.")
}

Salida:

Tu cupón activo es: BUEN FIN 2024

Si cuponDescuento fuera nil, entraría al bloque else sin ningún error.

2. Desenvoltorio con guard let

guard let es útil cuando quieres salir de una función si el valor no existe.

func mostrarRFC(_ rfc: String?) {
    guard let rfcValido = rfc else {
        print("RFC no registrado.")
        return
    }
    print("RFC del cliente: \(rfcValido)")
}

mostrarRFC("GÓMJ850312AB3")
mostrarRFC(nil)

Salida:

RFC del cliente: GÓMJ850312AB3
RFC no registrado.

3. Valor por defecto con ?? (operador nil-coalescing)

Este operador devuelve el valor del opcional si existe, o un valor por defecto si es nil.

var saldoMonedero: Double? = nil
let saldoMostrado: Double = saldoMonedero ?? 0.0
print("Saldo disponible: $\(saldoMostrado)")

Salida:

Saldo disponible: $0

Este operador es muy común en apps iOS para mostrar valores predeterminados cuando un dato no está disponible aún.

Errores comunes con tipos y opcionales

Error 1: mezclar tipos sin conversión

let precio: Double = 499.00
let cantidad: Int = 2
// let subtotal = precio * cantidad  // ❌ Error de compilación
let subtotal = precio * Double(cantidad)  // ✅ Correcto

Nunca asumas que Swift convertirá los tipos por ti. Siempre convierte de forma explícita.

Error 2: forzar el desenvoltorio con ! sin verificar

Swift permite desenvolver un opcional con ! (forzado). Esto es peligroso si el valor es nil.

var correoUsuario: String? = nil
print(correoUsuario!)  // ❌ Crash en tiempo de ejecución: Fatal error: unexpectedly found nil

Evita ! hasta que tengas experiencia. Usa if let o ?? en su lugar.

Error 3: olvidar que nil no es lo mismo que cero o vacío

var articulosGuardados: Int? = nil   // no sabemos cuántos hay
var articulosVacios: Int = 0         // sabemos que hay cero

Estos dos no son equivalentes. nil significa "no hay información". 0 significa "hay cero artículos". Tratar nil como si fuera 0 provoca errores lógicos en tu app.

Error 4: declarar todo como opcional por comodidad

Algunos principiantes agregan ? a todas sus variables para "evitar errores". Esto es contraproducente: pierdes las garantías de seguridad que Swift ofrece. Usa opcionales solo cuando el valor realmente puede no existir.

Ejemplo integrado: perfil de usuario en una app de tienda

Imagina que construyes una app para Liverpool. Al registrar un usuario, algunos datos son obligatorios y otros son opcionales.

let nombreCliente: String = "Mariana Torres"
let edadCliente: Int = 28
var telefonoSecundario: String? = nil
var saldoRecompensas: Double? = 350.75

// Mostrar teléfono secundario o mensaje alternativo
let telefonoMostrado: String = telefonoSecundario ?? "No registrado"
print("Teléfono secundario: \(telefonoMostrado)")

// Mostrar saldo si existe
if let saldo = saldoRecompensas {
    print("Tienes $\(saldo) en recompensas Liverpool.")
} else {
    print("Sin saldo de recompensas.")
}

Salida:

Teléfono secundario: No registrado
Tienes $350.75 en recompensas Liverpool.

Este patrón es exactamente lo que usarás en apps reales: datos obligatorios sin ?, datos que pueden faltar con ?.

Resumen de tipos y opcionales

Puntos clave

• Int, Double, String y Bool son los cuatro tipos fundamentales para apps iOS básicas.
• Swift no convierte tipos automáticamente: usa Double(miInt) o Int(miDouble) para convertir.
• Un opcional (Tipo?) puede contener un valor o ser nil. Úsalo solo cuando el dato realmente puede estar ausente.
• La forma más segura de usar un opcional es con if let o con el operador ?? para definir un valor por defecto.
• Evita el desenvoltorio forzado (!) hasta que domines los opcionales, ya que provoca crashes si el valor es nil.