Funciones y closures · Swift

Las funciones son los bloques de construcción de todo programa. En Swift tienen un par de rasgos propios (argument labels) y una versión “anónima” —los closures— que están en el corazón de SwiftUI y de casi toda API moderna de Swift.

🎯 Al terminar esta lección sabrás

Definir funciones con parámetros y retorno.
Argument labels y valores por defecto.
Qué es un closure y su sintaxis.
map, filter y reduce con closures.

Funciones

func saludar(nombre: String) -> String {
    return "Hola, \(nombre)"
}
let mensaje = saludar(nombre: "Ana")

-> String indica el tipo que devuelve. Si la función es una sola expresión, puedes omitir return:

func doble(_ x: Int) -> Int { x * 2 }

Argument labels

Swift distingue entre la etiqueta que usas al llamar y el nombre del parámetro dentro de la función. Esto hace las llamadas legibles como frases:

func mover(desde origen: String, hasta destino: String) {
    print("De \(origen) a \(destino)")
}
mover(desde: "Madrid", hasta: "Lisboa")   // se lee natural

El _ elimina la etiqueta (llamas sin nombrar el argumento):

func cuadrado(_ n: Int) -> Int { n * n }
cuadrado(5)    // sin etiqueta

Valores por defecto

func conectar(host: String, puerto: Int = 443) {
    print("\(host):\(puerto)")
}
conectar(host: "api.com")            // usa 443
conectar(host: "api.com", puerto: 80) // lo sobreescribe

Closures: funciones anónimas

Un closure es un bloque de código que puedes guardar en una variable y pasar por ahí, como si fuera un valor. La sintaxis: llaves, los parámetros y in, luego el cuerpo:

let sumar = { (a: Int, b: Int) -> Int in
    a + b
}
print(sumar(3, 4))   // 7

Los closures se usan muchísimo como argumentos de otras funciones. Cuando el closure es el último parámetro, Swift permite la “trailing closure syntax”, que lo saca de los paréntesis:

// estas dos llamadas son equivalentes
numeros.sorted(by: { a, b in a < b })
numeros.sorted { a, b in a < b }      // trailing closure, más limpio

ℹ️

Por qué importan tanto

SwiftUI está construido sobre closures: cuando escribes Button("Guardar") { guardar() }, ese { guardar() } es un trailing closure — el código que se ejecuta al pulsar. Entender los closures ahora hace que SwiftUI (Nivel 2) tenga sentido después.

map, filter, reduce

La tríada que transforma colecciones sin bucles manuales. Cada una recibe un closure:

let numeros = [1, 2, 3, 4, 5]

// map: transforma cada elemento
let dobles = numeros.map { $0 * 2 }          // [2, 4, 6, 8, 10]

// filter: se queda con los que cumplen
let pares = numeros.filter { $0 % 2 == 0 }   // [2, 4]

// reduce: combina todo en un valor
let suma = numeros.reduce(0) { $0 + $1 }     // 15

El $0 (y $1, $2…) son los argumentos abreviados del closure: $0 es el primero. Para closures cortos, es más limpio que nombrarlos.

⚡

Encadena transformaciones

La potencia real aparece al encadenar: describes la transformación como una tubería, no como un bucle con estado.

let resultado = numeros
    .filter { $0 % 2 == 0 }   // solo pares
    .map { $0 * $0 }          // al cuadrado
    .reduce(0, +)             // sumados

Se lee de arriba abajo como una receta: filtra, transforma, combina. Este estilo declarativo es el mismo que usarás en SwiftUI para describir interfaces. Interiorízalo aquí.

⚔️ Piensa en funciones y closures

Escribe una función saludar(a:) con argument label que devuelva un saludo.
Dale a un parámetro un valor por defecto y llámala de las dos formas.
Guarda un closure que multiplique dos números y úsalo.
Con un array de números: filtra los mayores que 3, multiplícalos por 10 y súmalos, encadenando filter, map y reduce.