Domina las funciones en Swift – Tutorial con ejemplos

En el vasto universo del desarrollo de software, independientemente del lenguaje que elijas, existe un átomo fundamental, una unidad indivisible de lógica que da vida a las aplicaciones: la función.

Si estás aprendiendo Swift, el lenguaje moderno y potente de Apple, te habrás dado cuenta de que es un lenguaje “opinionado”. Tiene una forma muy específica de hacer las cosas, priorizando la legibilidad y la seguridad. Las funciones en Swift no son solo bloques de código; son ciudadanos de primera clase que pueden pasarse como variables, transformar datos y estructurar arquitecturas complejas.

En este tutorial de profundidad técnica, desglosaremos qué es realmente una función en Swift, cómo su sintaxis difiere de otros lenguajes tipo C, y cómo puedes utilizarlas para escribir código modular, testearle y escalable.

1. ¿Qué es realmente una función?

Antes de escribir código, definamos el concepto. Una función es un bloque de código autónomo que realiza una tarea específica.

Imagina una máquina de café.

1. Entrada (Input): Le das granos de café y agua.
2. Procesamiento: La máquina muele, calienta y filtra.
3. Salida (Output): Te devuelve una taza de café caliente.

En programación, esto se traduce directamente:

• La función recibe parámetros (granos y agua).
• Ejecuta un cuerpo de código (el mecanismo interno).
• Devuelve un valor de retorno (la taza de café).

En Swift, las funciones son extremadamente flexibles. No necesitan tener entradas, ni siquiera necesitan devolver una salida visible.

2. La Sintaxis Básica: Tu Primera Función

Swift utiliza la palabra clave func para declarar funciones. A diferencia de lenguajes como Java o C++, donde el tipo de retorno va al principio, Swift utiliza una flecha -> para indicar qué saldrá de la función, lo que mejora la lectura de izquierda a derecha.

func nombreDeLaFuncion(parametro: Tipo) -> TipoDeRetorno {
    // Cuerpo de la función
    return valor
}

Veamos el ejemplo más simple posible: una función que solo imprime un mensaje.

func saludar() {
    print("¡Hola, mundo Swift!")
}

// Para ejecutarla, la "llamamos":
saludar()

Aquí no hay parámetros (los paréntesis están vacíos) y no hay flecha de retorno (implícitamente devuelve Void, o vacío).

3. Parámetros y Argumentos: El Arte de la Comunicación

Aquí es donde Swift brilla y se diferencia de la competencia. Swift hereda de Objective-C la filosofía de que el código debe leerse como una frase en inglés.

Para lograr esto, Swift distingue entre:

1. Nombre del parámetro (Parameter Name): Se usa dentro de la función.
2. Etiqueta del argumento (Argument Label): Se usa fuera de la función, al llamarla.

3.1. Parámetros Estándar

func cuadrado(numero: Int) -> Int {
    return numero * numero
}

let resultado = cuadrado(numero: 5) // Leemos: "cuadrado número 5"

3.2. Etiquetas de Argumento Personalizadas

A veces, cuadrado(numero: 5) suena redundante. O en otros casos, queremos que la llamada sea más fluida. Podemos definir una etiqueta externa diferente al nombre interno.

// 'to' es la etiqueta externa (para quien llama la función)
// 'person' es el nombre interno (para el código dentro de la función)
func sayHello(to person: String) {
    print("Hello, \(person)!")
}

// La llamada se lee como una frase natural:
sayHello(to: "Maria")

Si hubiéramos usado solo person, la llamada sería sayHello(person: "Maria"), que es más técnico y menos narrativo.

3.3. Omitiendo Etiquetas (_)

A veces, el contexto es tan obvio que no necesitamos ninguna etiqueta. Usamos el guion bajo _ para decirle a Swift: “ignora la etiqueta externa”.

func sumar(_ a: Int, _ b: Int) -> Int {
    return a + b
}

// Ahora parece una operación matemática pura
let suma = sumar(10, 5)

3.4. Valores por Defecto

¿Qué pasa si un parámetro suele ser casi siempre el mismo? En lugar de obligar al usuario a escribirlo siempre, podemos darle un valor predeterminado. Esto es vital para mantener limpias las APIs.

func crearBoton(titulo: String, color: String = "Azul") {
    print("Creando botón \(titulo) de color \(color)")
}

crearBoton(titulo: "Aceptar") // Usa "Azul" automáticamente
crearBoton(titulo: "Cancelar", color: "Rojo") // Sobrescribe con "Rojo"

Esto evita lo que en otros lenguajes se conoce como “Sobrecarga de Constructores” o tener múltiples funciones con el mismo nombre pero distintos parámetros solo para manejar opciones por defecto.

4. Retorno de Valores: Más allá del dato simple

Swift es un lenguaje fuertemente tipado. Si dices que devuelves un Int, debes devolver un Int. Pero Swift ofrece herramientas poderosas para manejar los retornos.

4.1. Tuplas: Retornando múltiples valores

En lenguajes antiguos, si querías devolver dos cosas (ej. coordenadas X e Y), tenías que crear una clase, un struct, o usar un array confuso. En Swift, usamos Tuplas.

func obtenerCoordenadasGPS() -> (latitud: Double, longitud: Double) {
    // Simulamos una lectura
    return (40.4168, -3.7038)
}

let posicion = obtenerCoordenadasGPS()

// Podemos acceder por nombre
print("Estás en la latitud: \(posicion.latitud)")

Las tuplas son ideales para grupos de datos ligeros y temporales que no requieren la formalidad de una estructura completa.

4.2. Optionals: Cuando la función puede fallar

A veces, una función no puede hacer su trabajo. Imagina una función que busca un usuario por ID en una base de datos. ¿Qué pasa si el ID no existe?

No deberíamos devolver un usuario vacío o un error genérico. Debemos devolver nil (nulo). Para eso, el tipo de retorno se marca con un signo de interrogación ?.

func buscarUsuario(id: Int) -> String? {
    let baseDeDatos = [1: "Ana", 2: "Carlos"]
    
    // Si encuentra el id devuelve el nombre, si no, devuelve nil
    return baseDeDatos[id]
}

// Manejo seguro del retorno
if let usuario = buscarUsuario(id: 99) {
    print("Usuario encontrado: \(usuario)")
} else {
    print("Usuario no existe")
}

5. Parámetros Variádicos (Variadic Parameters)

A veces no sabes cuántos parámetros te enviarán. ¿Quieres sumar 2 números? ¿O 20? Swift permite aceptar un número indefinido de parámetros de un mismo tipo usando tres puntos ....

func promedio(_ numeros: Double...) -> Double {
    // Dentro de la función, 'numeros' se comporta como un Array [Double]
    var total: Double = 0
    for numero in numeros {
        total += numero
    }
    return total / Double(numeros.count)
}

print(promedio(5, 10, 15, 20)) // Funciona con 4 argumentos
print(promedio(2, 4))          // Funciona con 2 argumentos

Es así como funciona la función print() de Swift, que puede recibir tantas cadenas como quieras separar por comas.

6. Funciones In-Out: Modificando la Realidad

Por defecto, los parámetros en Swift son constantes (let). Si intentas cambiar el valor de un parámetro dentro de la función, Swift te dará un error de compilación. Esto es por seguridad: evita efectos secundarios no deseados.

Pero, ¿y si necesitas modificar la variable original que te pasaron? Usamos la palabra clave inout.

func intercambiar(_ a: inout Int, _ b: inout Int) {
    let temporal = a
    a = b
    b = temporal
}

var x = 10
var y = 30

// Debemos usar '&' (ampersand) para indicar que estamos pasando la referencia
intercambiar(&x, &y)

print("x es ahora \(x), y es ahora \(y)") // x: 30, y: 10

Nota técnica: Esto se conoce como “Copy-in Copy-out” o paso por valor-resultado, aunque a efectos prácticos se comporta similar al paso por referencia de C++.

7. Tipos de Función: Funciones como Ciudadanos de Primera Clase

Este es un concepto que separa a los programadores novatos de los avanzados. En Swift, una función es un tipo de dato, igual que un Int o un String.

Esto significa que puedes:

1. Asignar una función a una variable.
2. Pasar una función como parámetro a otra función.
3. Devolver una función desde otra función.

El Tipo de Función

El “tipo” de una función se define por sus parámetros y su retorno. Ejemplo: Una función que toma dos Int y devuelve un Int es de tipo (Int, Int) -> Int.

func sumar(a: Int, b: Int) -> Int { return a + b }
func multiplicar(a: Int, b: Int) -> Int { return a * b }

// Variable que almacena UNA FUNCIÓN
var operacionMatematica: (Int, Int) -> Int

// Asignamos la función sumar
operacionMatematica = sumar
print(operacionMatematica(4, 2)) // Imprime 6

// Cambiamos a multiplicar dinámicamente
operacionMatematica = multiplicar
print(operacionMatematica(4, 2)) // Imprime 8

Este concepto es la base de la Programación Funcional y es esencial para entender herramientas de SwiftUI o manejo de arrays como map, filter y reduce.

8. Buenas Prácticas y Clean Code en Funciones

Saber la sintaxis es el 50%. El otro 50% es saber escribir funciones que tus compañeros de equipo (o tú mismo en 6 meses) puedan entender.

8.1. Principio de Responsabilidad Única (SRP)

Una función debe hacer una sola cosa y hacerla bien.

• Mal: func procesarDatosYGuardarEnBaseDeDatosYActualizarUI()
• Bien: func procesarDatos(), func guardar(), func actualizarUI()

Si tu función tiene más de 20 o 30 líneas, es una señal de alerta. Probablemente esté haciendo demasiado. Divídela.

8.2. Naming Convention (Convención de Nombres)

Los nombres deben ser verbos si realizan una acción (calcularTotal, descargarImagen) o sustantivos si devuelven un valor sin efectos secundarios (distancia(a:punto)).

En Swift, la claridad prima sobre la brevedad. No tengas miedo de nombres largos si son descriptivos.

8.3. Guard Statements (Salida Temprana)

Para evitar el “infierno de las llaves anidadas” (Pyramid of Doom), usa guard para validar las precondiciones al inicio de la función.

func dividir(dividendo: Double, divisor: Double) -> Double? {
    // Validación primero
    guard divisor != 0 else {
        print("Error: No se puede dividir por cero")
        return nil
    }
    
    // Si pasa el guard, el código sigue limpio, sin estar dentro de un 'else'
    return dividendo / divisor
}

9. Funciones Anidadas (Nested Functions)

A veces, tienes una función auxiliar que solo es útil dentro de otra función específica. Para no “contaminar” el espacio global de tu código, puedes definir funciones dentro de funciones.

func carreraEspacial(progreso: Int) {
    
    // Esta función solo existe dentro de 'carreraEspacial'
    func analizarCombustible() {
        print("Revisando niveles...")
    }
    
    analizarCombustible()
    print("Lanzando cohete al \(progreso)%")
}

Esto encapsula la lógica y mantiene tu código organizado.

10. Conclusión

Las funciones en Swift son una herramienta de ingeniería de precisión. La combinación de etiquetas de argumentos (para la legibilidad humana), tuplas (para la flexibilidad de datos) y su naturaleza de “First-Class Citizens” (para la potencia funcional), hacen que trabajar con ellas sea un placer.

Resumen de lo aprendido:

1. Usa func para declarar.
2. Usa -> para el retorno.
3. Las etiquetas de argumentos (to, from, _) hacen que tu código se lea como inglés.
4. Los valores por defecto limpian tu código de repeticiones.
5. Las funciones son tipos de datos; úsalas como variables para crear código modular.

¿Cuál es el siguiente paso?

Ahora que dominas la estructura, el siguiente paso lógico es aprender sobre Closures. Los closures son, esencialmente, funciones sin nombre que pueden pasarse como código compacto. Son el corazón de la asincronía y el manejo de eventos en Swift y SwiftUI.

Si tienes cualquier duda sobre este artículo, contacta conmigo y estaré encantado de ayudarte 🙂. Puedes contactar conmigo en mi perfil de X o en mi perfil de Instagram