Swift Academy · Lección

Cláusulas where en funciones

Añada restricciones detalladas a las funciones genéricas.

Cláusulas where en funciones es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Swift Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Swift Academy incluye 4 lecciones en total.

Más allá de las restricciones simples

Una restricción como <T: Collection> describe el propio T. Sin embargo, a veces es necesario restringir los tipos asociados de T, como su Element. Para eso sirve una cláusula where.

func sumInts<C: Collection>(_ c: C) -> Int where C.Element == Int {
    c.reduce(0, +)
}
print(sumInts([1, 2, 3]))

Requisito de igualdad de tipos

where C.Element == Int exige que los elementos de la colección sean exactamente Int, lo que permite realizar operaciones específicas con enteros.

func describe<C: Collection>(_ c: C) -> String where C.Element == Int {
    "Sum is " + String(c.reduce(0, +))
}
print(describe(Set([1, 2, 3])))

Requisito de protocolo para el elemento

Puede exigir que el elemento conforme con un protocolo en lugar de exigir un único tipo exacto, lo que ofrece mayor flexibilidad.

func joinAll<C: Collection>(_ c: C) -> String
    where C.Element: CustomStringConvertible {
    c.map { $0.description }.joined(separator: ", ")
}
print(joinAll([1, 2, 3]))

where va después de la firma

La cláusula where se sitúa entre el tipo devuelto y el cuerpo de la función. Las restricciones dentro de <> y la cláusula where funcionan conjuntamente.

func maxElement<C: Collection>(_ c: C) -> C.Element?
    where C.Element: Comparable {
    c.max()
}
print(maxElement([4, 9, 2])!)

Relación entre dos parámetros de tipo

Una cláusula where puede vincular mediante == los tipos de elemento de dos genéricos diferentes.

func combine<A: Collection, B: Collection>(_ a: A, _ b: B) -> [A.Element]
    where A.Element == B.Element {
    Array(a) + Array(b)
}
print(combine([1, 2], Set([3])))

Varias condiciones where

Indique varios requisitos separados por comas para expresar restricciones compuestas.

func report<C: Collection>(_ c: C)
    where C.Element: Comparable, C.Element: CustomStringConvertible {
    if let m = c.max() { print("max:", m.description) }
}
report([5, 1, 9])

Restricción de tipos asociados anidados

Puede profundizar más; por ejemplo, exigir el tipo del elemento de un elemento al trabajar con colecciones anidadas.

func flatten<C: Collection>(_ c: C) -> [Int]
    where C.Element: Collection, C.Element.Element == Int {
    c.flatMap { Array($0) }
}
print(flatten([[1, 2], [3]]))

where con elementos Equatable

Exigir elementos Equatable permite buscar en una colección genérica.

func indexOf<C: Collection>(_ x: C.Element, in c: C) -> C.Index?
    where C.Element: Equatable {
    c.firstIndex(of: x)
}
if let i = indexOf(2, in: [1, 2, 3]) { print("found") }

Métodos genéricos con where

Los métodos dentro de tipos genéricos también utilizan where, a menudo para añadir comportamiento solo para determinados tipos de elemento.

struct Wrap<T> {
    let items: [T]
    func total() -> Int where T == Int { items.reduce(0, +) }
}
print(Wrap(items: [1, 2, 3]).total())

Ventaja de legibilidad

Las restricciones complejas se leen con mayor claridad en una cláusula where que comprimidas dentro de los corchetes angulares, especialmente cuando hay varias condiciones sobre tipos asociados.

func first<C: Collection>(_ c: C) -> String
    where C.Element: CustomStringConvertible {
    c.first.map { $0.description } ?? "empty"
}
print(first([10, 20]))

where en la biblioteca estándar

Métodos como joined() en secuencias de secuencias utilizan internamente cláusulas where para expresar sus requisitos con precisión.

let nested = [[1, 2], [3, 4]]
print(Array(nested.joined()))

Comprobación rápida

Compruebe su comprensión de las cláusulas where en funciones.

Resumen

Las cláusulas where permiten restringir los tipos asociados de un genérico: exigir que un elemento sea un tipo específico (== Int), que conforme con un protocolo (: Comparable), relacionar los elementos de dos parámetros o acceder a tipos asociados anidados. Se sitúan después de la firma y mantienen legibles las restricciones complejas.

Preguntas frecuentes

¿La lección «Cláusulas where en funciones» es gratis?

Sí — el texto completo de «Cláusulas where en funciones» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Swift Academy, actualiza a CoddyKit PRO. El curso de Swift Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Cláusulas where en funciones»?

Añada restricciones detalladas a las funciones genéricas. Practicas Swift Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Swift Academy?

No se requiere experiencia previa. Swift Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Cláusulas where en funciones»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Swift Academy?

Sí. Cada lección de Swift Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Swift Academy