Básico 01 – Variables, constantes y colecciones (2026).

Esta es una versión actualizada del post original publicado en 2021. Swift ha madurado muchísimo y en 2026 hay convenciones y buenas prácticas que todo desarrollador debería conocer desde el principio. Repasamos los fundamentos con el Swift moderno que se usa hoy en día.

¿Qué son las variables y constantes?

Las variables y constantes son los nombres que asignamos a espacios de memoria para almacenar valores que usaremos a lo largo de nuestro código. En Swift la distinción entre ambas es fundamental y el compilador te obliga a ser explícito desde el primer día.

Constantes con let — el valor predeterminado en Swift moderno

En Swift moderno la regla de oro es: usa let siempre que puedas, usa var solo cuando necesites cambiar el valor. Esto no es solo estilo, el compilador te advertirá si declaras una var que nunca modificas.

let idioma = "Swift"
let añoActual = 2026
let pi = 3.14159

// Intentar modificar una constante es un error de compilación
// idioma = "Otro"  ❌ error: cannot assign to value: 'idioma' is a 'let' constant

Variables con var — cuando el valor cambia

Usa var únicamente cuando el valor necesita cambiar durante la ejecución del programa. Ejemplos comunes: contadores, estados de una vista, resultados de cálculos dinámicos.

var puntuacion = 0
puntuacion += 10
puntuacion += 25
print(puntuacion) // 35

var estadoCarga = false
estadoCarga = true  // ✅ válido porque es var

Inferencia de tipos — Swift lo deduce por ti

Swift es un lenguaje de tipado estático pero con inferencia de tipos muy poderosa. En la práctica no necesitas escribir el tipo explícitamente la mayoría de las veces — el compilador lo deduce del valor inicial. Este es el estilo idiomático en Swift moderno.

// Swift infiere el tipo automáticamente ✅ (estilo recomendado)
let titulo = "Hola Swift"        // String
let version = 2                  // Int
let precio = 0.99                // Double
let disponible = true            // Bool

// Anotación explícita — úsala cuando aporte claridad
let identificador: UUID = UUID()
let limiteDescarga: Int = 100

Una nota importante: Swift infiere los literales decimales como Double por defecto, no como Float. En Swift moderno Double es el tipo estándar para decimales — tiene más precisión (64 bits vs 32 bits) y es lo que usan la mayoría de las APIs de Apple.

Tipos básicos en Swift

let texto: String = "Hola desde Swift"     // Cadenas de texto
let entero: Int = 42                        // Números enteros
let decimal: Double = 3.14159              // Decimales (preferir Double sobre Float)
let bandera: Bool = true                   // true o false
let caracter: Character = "A"             // Un solo carácter (raro en la práctica)

En la práctica del día a día Character casi no se usa directamente — normalmente trabajamos con String y lo manipulamos. No te preocupes demasiado por ese tipo.

Interpolación de Strings

Una de las características más usadas en Swift es la interpolación de strings con \(). Permite insertar valores directamente dentro de un texto sin concatenar con +.

let producto = "Suscripción"
let version = 3
let descripcion = "Bienvenido a \(producto) versión \(version)"
print(descripcion) // "Bienvenido a Suscripción versión 3"

// También puedes incluir expresiones
let descuento = 0.20
let precio = 9.99
print("Precio final: \(precio * (1 - descuento))") // "Precio final: 7.992"

Tuples — agrupar valores relacionados

Las tuplas permiten agrupar múltiples valores en uno. Son ideales para retornar más de un valor desde una función o representar un dato compuesto simple. En Swift moderno se usan mucho con nombres de elementos para mejorar la legibilidad.

// Tupla con nombres — mucho más legible
let respuestaHTTP = (codigo: 200, mensaje: "OK")
print(respuestaHTTP.codigo)   // 200
print(respuestaHTTP.mensaje)  // "OK"

// También puedes desestructurarla directamente
let (codigo, mensaje) = respuestaHTTP
print(codigo)    // 200
print(mensaje)   // "OK"

// Ignorar valores que no necesitas con _
let (estadoHTTP, _) = respuestaHTTP
print(estadoHTTP) // 200

Nota: Para datos más complejos o que se reutilizan en varios lugares, prefiere usar struct en lugar de una tupla. Las tuplas son convenientes para uso interno rápido, no para APIs públicas.

Colecciones

Swift tiene tres tipos de colecciones principales: Array, Dictionary y Set. En Swift moderno se declaran casi siempre con inferencia de tipos y literales.

Array — lista ordenada

Un arreglo almacena valores del mismo tipo en orden. Los elementos pueden repetirse y se acceden por índice.

// Declaración moderna — Swift infiere [String]
var colores = ["Rojo", "Verde", "Azul"]

// Agregar elementos
colores.append("Amarillo")

// Acceder por índice (base 0)
print(colores[0])  // "Rojo"

// Iterar (forma idiomática en Swift)
for color in colores {
    print(color)
}

// Útiles en Swift moderno
print(colores.count)        // número de elementos
print(colores.isEmpty)      // false
colores.remove(at: 1)       // elimina "Verde"
colores.removeAll()         // vacía el array

Dictionary — pares llave-valor

Un diccionario almacena pares de llave-valor sin orden garantizado. Las llaves deben ser únicas. Es el equivalente a un HashMap en otros lenguajes.

// Swift infiere [String: Int]
var puntajes = ["Jugador1": 100, "Jugador2": 95, "Jugador3": 88]

// Acceder — retorna Optional porque la llave podría no existir
if let puntos = puntajes["Jugador1"] {
    print("Puntos: \(puntos)")  // "Puntos: 100"
}

// Agregar o modificar
puntajes["Jugador4"] = 75
puntajes["Jugador1"] = 110

// Eliminar
puntajes["Jugador3"] = nil

// Iterar
for (jugador, puntos) in puntajes {
    print("\(jugador): \(puntos)")
}

Set — valores únicos sin orden

Un Set almacena valores únicos sin orden. Es ideal cuando necesitas garantizar que no haya duplicados o cuando necesitas operaciones de conjuntos (unión, intersección, diferencia).

// Requiere anotación explícita porque el literal es igual al de Array
var categorias: Set = ["Juegos", "Utilidades", "Educacion"]

categorias.insert("Productividad")
categorias.remove("Juegos")

// Los duplicados se ignoran automáticamente
categorias.insert("Utilidades")  // no cambia nada
print(categorias.count)  // sigue siendo 3

// Operaciones de conjuntos
let grupo1: Set = [1, 2, 3, 4]
let grupo2: Set = [3, 4, 5, 6]

print(grupo1.union(grupo2))         // {1, 2, 3, 4, 5, 6}
print(grupo1.intersection(grupo2))  // {3, 4}

¿Cuándo usar cada colección?

• Usa Array cuando el orden importa o necesitas acceder por posición.
• Usa Dictionary cuando necesitas buscar valores por una llave identificadora.
• Usa Set cuando la unicidad de los elementos es lo más importante y el orden no te importa.

Resumen: las reglas de oro del Swift moderno

1. Prefiere let sobre var — usa var Solo cuando el valor realmente cambia.
2. Confía en la inferencia de tipos — no escribas el tipo si Swift puede deducirlo.
3. Usa Double en lugar de Float para decimales en la mayoría de los casos.
4. Nombra tus tuplas — hace el código mucho más legible.
5. Elige la colección correcta — Array para orden, Dictionary para búsqueda por llave, Set para unicidad.
   

Puedes usar el siguiente playground para practicar por tu cuenta:

En el siguiente post de la serie veremos los operadores básicos en Swift moderno — comparación, lógicos, rango y el operador nil-coalescing que usarás constantemente.