Composición de protocolos
Combine varios requisitos de protocolos con &.
Composición de protocolos es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 3 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.
Combinar protocolos
A veces un valor debe cumplir varios protocolos a la vez. Swift permite componer protocolos con el operador &: SomeProtocol & AnotherProtocol.
protocol Named { var name: String { get } }
protocol Aged { var age: Int { get } }Un parámetro compuesto
Un parámetro de tipo Named & Aged acepta cualquier valor que cumpla ambos protocolos.
protocol Named { var name: String { get } }
protocol Aged { var age: Int { get } }
struct Person: Named, Aged {
let name: String
let age: Int
}
func intro(_ x: Named & Aged) {
print(x.name + " is " + String(x.age))
}
intro(Person(name: "Sam", age: 28))¿Por qué no usar herencia?
La composición permite exigir ambos protocolos en el punto de llamada sin crear un nuevo protocolo combinado. Mantiene los protocolos pequeños y reutilizables.
protocol Drawable { func draw() -> String }
protocol Resizable { func resize(_ f: Double) -> String }
struct Icon: Drawable, Resizable {
func draw() -> String { "drawing" }
func resize(_ f: Double) -> String { "x" + String(f) }
}
func render(_ v: Drawable & Resizable) {
print(v.draw(), v.resize(2))
}
render(Icon())Tres o más
Puede encadenar tantos protocolos como necesite mediante operadores & adicionales.
protocol A { func a() -> String }
protocol B { func b() -> String }
protocol C { func c() -> String }
struct X: A, B, C {
func a() -> String { "a" }
func b() -> String { "b" }
func c() -> String { "c" }
}
func use(_ v: A & B & C) { print(v.a(), v.b(), v.c()) }
use(X())Composición con una clase
Puede combinar un tipo de clase con protocolos: SomeClass & SomeProtocol exige que el valor sea esa clase o una subclase Y que cumpla el protocolo.
class Vehicle { var speed = 0 }
protocol Electric { var battery: Int { get } }
class Tesla: Vehicle, Electric { var battery = 100 }
func check(_ v: Vehicle & Electric) {
print(v.speed, v.battery)
}
check(Tesla())Devolver una composición
Una función puede devolver un tipo compuesto y prometer a quien la llama que el resultado cumple todos los protocolos indicados.
protocol Named { var name: String { get } }
protocol Aged { var age: Int { get } }
struct Person: Named, Aged { let name: String; let age: Int }
func makePerson() -> Named & Aged {
Person(name: "Eve", age: 22)
}
let p = makePerson()
print(p.name, p.age)typealias para una composición
Asigne un nombre legible a una composición con typealias para poder reutilizarla sin repetir la cadena de &.
protocol Codable2 { func encode() -> String }
protocol Loggable { func log() -> String }
typealias Persistable = Codable2 & Loggable
struct Record: Persistable {
func encode() -> String { "data" }
func log() -> String { "logged" }
}
func save(_ r: Persistable) { print(r.encode(), r.log()) }
save(Record())Composición en colecciones
Puede almacenar valores de tipo compuesto en matrices y acceder a los miembros de todos los protocolos en cada elemento.
protocol Named { var name: String { get } }
protocol Aged { var age: Int { get } }
struct P: Named, Aged { let name: String; let age: Int }
let group: [Named & Aged] = [P(name: "A", age: 1), P(name: "B", age: 2)]
for g in group { print(g.name, g.age) }Composición con protocolos estándar
La composición resulta especialmente útil con protocolos de biblioteca. Por ejemplo, puede exigir tanto CustomStringConvertible como Equatable.
func report<T>(_ items: [T]) where T: CustomStringConvertible & Equatable {
for i in items { print(i.description) }
}
report([1, 2, 3])Protocolos vacíos como marcadores
La composición puede combinar un protocolo marcador (sin requisitos) con uno funcional para expresar la intención en el sistema de tipos.
protocol Secure {}
protocol Sendable2 { func send() -> String }
struct Packet: Secure, Sendable2 {
func send() -> String { "sent securely" }
}
func transmit(_ p: Secure & Sendable2) { print(p.send()) }
transmit(Packet())Composición frente a genéricos
La composición (A & B) elimina el tipo concreto; los genéricos (<T: A & B>) lo conservan. Utilice genéricos cuando necesite relacionar los tipos de los parámetros y los valores devueltos.
protocol A { func a() -> String }
protocol B { func b() -> String }
struct S: A, B { func a() -> String { "a" }; func b() -> String { "b" } }
func generic<T: A & B>(_ x: T) -> T { print(x.a(), x.b()); return x }
_ = generic(S())Comprobación rápida
Compruebe su comprensión de la composición de protocolos.
Resumen
La composición de protocolos con & permite exigir la conformidad con varios protocolos (y, opcionalmente, una clase) a la vez, sin definir un protocolo combinado nuevo. Puede asignar nombres a las composiciones con typealias, utilizarlas en parámetros, valores devueltos y colecciones, y ha visto en qué se diferencia la composición de los genéricos al conservar los tipos concretos.
Preguntas frecuentes
¿La lección «Composición de protocolos» es gratis?
Sí — el texto completo de «Composición de protocolos» 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 «Composición de protocolos»?
Combine varios requisitos de protocolos con &. 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 3 de 4.
¿Cuánto tiempo toma la lección «Composición de protocolos»?
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
- Los protocolos como contratos
- Implementaciones predeterminadas en extensiones
- Composición de protocolos
- Conformidad condicional