Swift: qué es, sintaxis y conceptos clave del lenguaje

¿Qué es Swift?

Swift es un lenguaje de programación multiparadigma desarrollado por Apple para iOS, macOS, watchOS, tvOS y visionOS. Los objetivos clave del lenguaje son: seguridad, velocidad y expresividad sintáctica. Swift utiliza el compilador LLVM y genera código máquina optimizado, comparable en rendimiento a C++.

Desde su lanzamiento en 2014, Swift ha pasado por 6 versiones principales. Swift 6 (2024) introdujo un modelo completo de seguridad contra carreras de datos mediante un control estricto del aislamiento de código concurrente. Según GitHub Octoverse 2025, Swift está entre los 10 idiomas con mayor crecimiento de comunidad, superando a Rust y Kotlin en velocidad de adopción en plataformas Apple.

Swift es abierto y multiplataforma — el código fuente se publica en GitHub (Swift Open Source). Además de las plataformas Apple, Swift se usa en Linux y Windows para desarrollo backend (Vapor, Hummingbird), aunque su ámbito principal sigue siendo el desarrollo móvil y de escritorio en el ecosistema Apple.

Por qué Swift reemplazó a Objective-C

Las razones principales de la transición: Swift elimina clases enteras de errores posibles en Objective-C. Type safety previene la incoherencia de tipos en tiempo de compilación. Optionals eliminan las desreferencias nil. ARC está integrado desde el primer día, a diferencia de MRC/ARC en Objective-C. La sintaxis de Swift es más corta y legible — los estudios muestran una reducción del 30-40% en el volumen de código en comparación con Objective-C para tareas equivalentes.

Sintaxis y construcciones básicas

La sintaxis básica de Swift combina construcciones familiares similares a C con elementos de lenguajes funcionales. Las variables se declaran con var, las constantes con let. El compilador usa inferencia de tipos, por lo que la anotación explícita de tipo solo se requiere en caso de ambigüedad.

import Foundation

// Constantes y variables
let name = "Swift"
var version = 6.0
var count: Int = 42

// Funciones con parámetros por defecto
func greet(person: String, greeting: String = "Hello") -> String {
    return "\(greeting), \(person)!"
}

// Guard-let para salida temprana
func parse(input: String?) -> Int {
    guard let value = input, let number = Int(value) else {
        return 0
    }
    return number
}

Switch y pattern matching en Swift son más potentes que en C y Kotlin. Switch admite coincidencia con tuplas, rangos, condiciones where y vinculación de valores. El compilador verifica la cobertura exhaustiva de todos los casos — omitir default no es un error si todos los valores posibles están cubiertos.

let point = (x: 3, y: -1)

switch point {
case (0, 0):
    print("Origen")
case let (x, y) where x == y:
    print("X es igual a Y")
case let (x, y) where abs(y) > x:
    print("El valor absoluto de Y es mayor que X")
default:
    print("Punto \("point.x), \(point.y))")
}

Optionals y trabajo seguro con nil

Optionals son un concepto central de Swift que resuelve el problema de las referencias null a nivel del sistema de tipos. Optional es un enum con dos casos: .none (nil) y .some(Wrapped). El compilador prohíbe usar un Optional sin verificación explícita, lo que elimina toda una clase de errores en tiempo de ejecución.

var optionalString: String? = "Hello"
optionalString = nil  // permitido

// Optional Binding — extracción segura
if let text = optionalString {
    print("Texto: \("text)")
} else {
    print("Valor ausente")
}

// Optional Chaining — acceso seguro a propiedades
let length = optionalString?.count ?? 0

// Operador nil-coalescing
let greeting = optionalString ?? "Default"

Optional Chaining con el operador ?. permite llamar métodos y acceder a propiedades de un valor opcional de forma segura. Si la cadena se interrumpe con nil, el resultado de toda la expresión es nil. Nil-coalescing (??) proporciona un valor predeterminado y se usa ampliamente en código de UI para mostrar texto placeholder.

Protocolos y extensiones

Protocols en Swift definen un contrato — un conjunto de propiedades y métodos. A diferencia de las interfaces de Java, los protocolos de Swift pueden tener implementaciones predeterminadas mediante protocol extensions. Esta es la base de la Programación Orientada a Protocolos, el enfoque recomendado por Apple en lugar de la herencia de clases.

protocol NamedEntity {
    var name: String { get }
    func description() -> String
}

// Implementación predeterminada mediante extension
extension NamedEntity {
    func description() -> String {
        return "Entity: \(name)"
    }
}

// Conformidad mediante extension
extension String: NamedEntity {
    var name: String { return self }
}

Protocol Extensions permiten añadir métodos a un protocolo sin modificar cada tipo conforme. Esto es especialmente útil para agregar utilidades comunes: map, filter, reduce para Sequence, o Codable para serialización JSON. Apple construyó muchos frameworks (SwiftUI, Combine) sobre protocolos con extensiones.

Closures y cadenas funcionales

Closures en Swift son funciones anónimas que capturan variables del contexto externo. Sintácticamente, los closures se parecen a las lambdas en Kotlin pero con una sintaxis más flexible: trailing closure, nombres de argumentos abreviados ($0, $1) y autoclosures.

// Closure con captura de contexto
let numbers = [5, 3, 8, 1, 9]

// Trailing closure syntax
let sorted = numbers.sorted { $0 < $1 }

// Cadena funcional
let result = numbers
    .filter { $0 > 3 }
    .map { $0 * 2 }
    .reduce(0, +)

// Closure como parámetro de función
func performAsync(completion: @escaping (Result<Data, Error>) -> Void) { }

Los closures @escaping se utilizan cuando el closure se ejecuta después del retorno de la función — típicamente para solicitudes de red y operaciones asíncronas. @autoclosure envuelve automáticamente una expresión en un closure, usado en assert y lógica de cortocircuito.

Estructuras y clases: comparación

La elección entre struct y class es una de las primeras decisiones al diseñar un modelo en Swift. Apple recomienda usar struct por defecto (tipo valor) y pasar a class (tipo referencia) solo cuando se necesita herencia o identidad por referencia.

Los tipos valor (struct) son más seguros en entornos multiproceso — cada hilo obtiene una copia independiente. Los tipos referencia (class) son necesarios para trabajar con UIKit (UIView, UIViewController), donde se requiere identidad por referencia y herencia de clases del sistema.

Gestión de memoria ARC

ARC (Automatic Reference Counting) es el sistema de gestión de memoria de Swift para tipos referencia. El compilador inserta llamadas retain/release en tiempo de ejecución, rastreando el número de referencias fuertes a un objeto. Cuando el contador llega a cero, el objeto se libera inmediatamente.

El principal problema de ARC son los retain cycles (ciclos de retención). Cuando dos objetos mantienen referencias fuertes entre sí, la memoria nunca se libera. La solución son las referencias weak (se vuelven nil automáticamente al liberarse) y las referencias unowned (garantizan que el objeto está vivo).

class ProfileViewController: UIViewController {
    var onLogout: (() -> Void)?
    
    func setupHandler() {
        // [weak self] previene el retain cycle
        onLogout = { [weak self] in
            guard let self else { return }
            self.dismiss(animated: true)
        }
    }
}

Para prevenir retain cycles en closures, use [weak self] con guard let self = self else { return }. Esta regla es especialmente importante en UIKit, donde ViewController mantiene referencias fuertes a sus propiedades y los closures dentro de esas propiedades referencian al ViewController.