Swift Academy · Lección

Principios del diseño orientado a protocolos

Priorice la composición de protocolos sobre la herencia de clases para lograr un diseño flexible.

Principios del diseño orientado a protocolos es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 4 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.

Bienvenida

La programación orientada a protocolos (POP) favorece la composición de protocolos frente a la herencia de clases para crear código Swift flexible, comprobable y reutilizable.

El problema de la herencia

Las jerarquías profundas de clases causan problemas: • Las subclases heredan TODO el estado y comportamiento de la superclase • Cambiar una superclase puede romper sus subclases • No se puede heredar de dos clases Los protocolos resuelven los tres problemas.

Comenzar con un protocolo

```swift protocol Greetable { var greeting: String { get } func greet() } extension Greetable { func greet() { print(greeting) } // default implementation } ``` Las extensiones de protocolos proporcionan implementaciones predeterminadas que cualquier tipo conformante obtiene automáticamente.

Composición de comportamientos

```swift protocol Persistable { func save() } protocol Networked { func fetch() async throws -> Data } protocol Loggable { func log(_ msg: String) } struct DataService: Persistable, Networked, Loggable { ... } ``` Combine comportamientos como piezas de LEGO; no necesita una jerarquía de clases.

Extensiones de protocolos para lógica compartida

```swift extension Loggable { func log(_ msg: String) { print("[\(type(of: self))] \(msg)") } } // Every Loggable type gets this for free ```

Modelado retroactivo

Los protocolos se pueden aplicar a tipos que no son de su propiedad: ```swift protocol JSONConvertible { func toJSON() -> String } extension Int: JSONConvertible { func toJSON() -> String { "\(self)" } } ``` Añada conformidades a tipos de la biblioteca estándar sin crear subclases.

Tipos de valor + protocolos

Las estructuras que conforman a protocolos le proporcionan semántica de valor *y* polimorfismo: ```swift protocol Shape { var area: Double { get } } struct Circle: Shape { var radius: Double; var area: Double { .pi * radius * radius } } struct Square: Shape { var side: Double; var area: Double { side * side } } let shapes: [any Shape] = [Circle(radius:3), Square(side:4)] shapes.map { $0.area } // [28.27, 16] ```

Inyección de dependencias mediante protocolos

```swift protocol DataStore { func save(_ data: Data) } struct FileStore: DataStore { func save(_ d: Data) { /* disk */ } } struct MockStore: DataStore { func save(_ d: Data) { /* test log */ } } class Service { let store: DataStore init(store: DataStore) { self.store = store } } ```

Cuándo usar clases

Prefiera las clases cuando: • Necesite un estado mutable compartido (semántica de referencia) • Necesite integrarse con API de ObjC/UIKit • La herencia sea el modelo adecuado (algo poco frecuente) Como regla predeterminada, use protocolos y estructuras para todo lo demás.

Convenciones para nombrar protocolos

• Protocolos de capacidades: sufijos `-able`, `-ible`, `-ing` (Equatable, Hashable, Coding) • Protocolos de delegación: sufijo `Delegate` o `DataSource` • Rol abstracto: sustantivo (`Store`, `Parser`, `Renderer`) Los buenos nombres hacen que el código orientado a protocolos se explique por sí mismo.

Comprobación rápida

¿Qué proporcionan las extensiones de protocolos a los tipos conformantes?

Repaso

Puntos clave: • Prefiera protocolos y estructuras a las jerarquías de clases • Las extensiones de protocolos proporcionan implementaciones predeterminadas compartidas • Combine comportamientos a partir de protocolos pequeños y con una única responsabilidad • Los protocolos permiten la inyección de dependencias para facilitar las pruebas • Reserve las clases para la semántica de referencia y la interoperabilidad con ObjC ¡Curso completado! Siguiente: tipos de valor frente a tipos de referencia en profundidad.

Preguntas frecuentes

¿La lección «Principios del diseño orientado a protocolos» es gratis?

Sí — el texto completo de «Principios del diseño orientado a 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 «Principios del diseño orientado a protocolos»?

Priorice la composición de protocolos sobre la herencia de clases para lograr un diseño flexible. 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 4 de 4.

¿Cuánto tiempo toma la lección «Principios del diseño orientado a 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

Composición de protocolos con &
Conformidad condicional
Requisitos de Self y diseño con Equatable
Principios del diseño orientado a protocolos

← Volver a Swift Academy