Extensiones de protocolos frente a extensiones de tipos
Compare las extensiones de protocolos (añaden implementaciones predeterminadas a un protocolo, incluso condicionalmente) con las extensiones de tipos (añaden APIs a un tipo concreto). Comprenda el comportamiento del dispatch y las restricciones.
Extensiones de protocolos frente a extensiones de tipos es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 2 de 3. 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 3 lecciones en total.
Descripción general
Objetivo: sepa cuándo usar una extensión de protocolo (comportamiento predeterminado para todos los tipos conformes) frente a una extensión de tipo (API para un único tipo concreto). También veremos las reglas de despacho.
Protocolo y conformidad
Los protocolos declaran requisitos. Los tipos se ajustan a ellos al implementar esos requisitos.
protocol Greeter {
func greet() -> String
}
struct Person: Greeter {
var name: String
func greet() -> String { "Hi, I'm \\(name)" } // concrete requirement impl
}
print(Person(name: "Ada").greet())Implementaciones predeterminadas mediante extensiones de protocolo
Una extensión de protocolo puede proporcionar implementaciones predeterminadas que utilizan todos los tipos conformes, salvo que proporcionen las suyas propias.
protocol Describable {
func describe() -> String
}
extension Describable {
// default for ALL conformers until they override
func describe() -> String { "No description" }
}
struct Car: Describable { } // uses default
struct Book: Describable {
func describe() -> String { "A book" } // custom override
}
print(Car().describe(), Book().describe())API de extensiones de tipo
Las extensiones de tipo añaden métodos y propiedades calculadas a un único tipo concreto. No añaden propiedades almacenadas.
struct Point { var x: Int; var y: Int }
extension Point {
// add helper just to Point
var lengthSquared: Int { x*x + y*y }
func moved(dx: Int, dy: Int) -> Point { Point(x: x+dx, y: y+dy) }
}
let p = Point(x: 2, y: 3)
print(p.lengthSquared, p.moved(dx: 1, dy: -1))Extensiones condicionales
Añada comportamiento a algunos tipos conformes mediante una cláusula where en la extensión del protocolo.
protocol Summable { }
extension Int: Summable { }
extension Array where Element: Summable {
// only for arrays whose elements conform to Summable
func joinedCount() -> Int { self.count }
}
print([1,2,3].joinedCount()) // works (Int conforms)
// print(["a","b"].joinedCount()) // not availableComportamiento del despacho (descripción general)
Regla general: si un método es un requisito del protocolo y un tipo conforme lo implementa, esa implementación prevalece (de forma similar a la dinámica). Los métodos añadidos únicamente en una extensión de protocolo, que no sean requisitos, usan despacho estático.
protocol Speaker { func speak() -> String }
extension Speaker { func speak() -> String { "default" } }
struct Cat: Speaker { }
struct Dog: Speaker {
func speak() -> String { "woof" } // requirement impl overrides default
}
let s1: Speaker = Cat()
let s2: Speaker = Dog()
print(s1.speak()) // "default" (uses default impl)
print(s2.speak()) // "woof" (Dog provides requirement impl)
let c = Cat()
print(c.speak()) // "default" via extension on protocolExtensión de protocolo frente a extensión de tipo
Comprobación rápida: ¿Cuál es la diferencia principal?
Resumen
Resumen: Use extensiones de protocolo para valores predeterminados reutilizables, opcionalmente condicionales. Use extensiones de tipo para ampliar un único tipo. Recuerde el despacho: las implementaciones de requisitos tienen prioridad sobre los métodos predeterminados de las extensiones.
Preguntas frecuentes
¿La lección «Extensiones de protocolos frente a extensiones de tipos» es gratis?
Sí — el texto completo de «Extensiones de protocolos frente a extensiones de tipos» 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 3 lecciones en total.
¿Qué aprenderé en «Extensiones de protocolos frente a extensiones de tipos»?
Compare las extensiones de protocolos (añaden implementaciones predeterminadas a un protocolo, incluso condicionalmente) con las extensiones de tipos (añaden APIs a un tipo concreto). Comprenda el co… 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 3.
¿Cuánto tiempo toma la lección «Extensiones de protocolos frente a extensiones de tipos»?
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
- Fundamentos de Protocols y Extensions
- Extensiones de protocolos frente a extensiones de tipos
- Requisitos static frente a instance