0Pricing
Swift Academy · Lección

Requisitos de Self y diseño con Equatable

Comprenda los protocolos que utilizan Self y cómo Equatable/Comparable lo aprovechan.

Requisitos de Self y diseño con Equatable 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.

Bienvenida

`Self` en un protocolo hace referencia al tipo concreto que conforma al protocolo. Permite que protocolos como `Equatable` y `Comparable` funcionen de forma segura con tipos heterogéneos.

Self como tipo de parámetro

```swift protocol Equatable { static func == (lhs: Self, rhs: Self) -> Bool } ``` `Self` significa que ambos parámetros deben ser del *mismo* tipo concreto. No puede comparar un `Int` con un `String` mediante este protocolo.

Conformidad con Equatable

```swift struct Point: Equatable { var x: Double var y: Double // Auto-synthesised: // static func == (lhs: Point, rhs: Point) -> Bool // { lhs.x == rhs.x && lhs.y == rhs.y } } print(Point(x:1,y:2) == Point(x:1,y:2)) // true ```

Comparable con Self

```swift struct Version: Comparable { let major, minor, patch: Int static func < (lhs: Version, rhs: Version) -> Bool { (lhs.major, lhs.minor, lhs.patch) < (rhs.major, rhs.minor, rhs.patch) } } let v1 = Version(major:1,minor:2,patch:0) let v2 = Version(major:2,minor:0,patch:0) print(v1 < v2) // true ```

Self como tipo de retorno

```swift protocol Clonable { func clone() -> Self } class Animal: Clonable { var name: String = "" required init() {} func clone() -> Self { type(of: self).init() } } ``` `Self` en el tipo de retorno significa que las subclases devuelven su propio tipo, no `Animal`.

Protocolo con requisito de Self (PAT)

```swift protocol Scalable { func scaled(by factor: Double) -> Self } struct Size: Scalable { var w, h: Double func scaled(by f: Double) -> Size { Size(w: w*f, h: h*f) } } ```

Hashable: Self + Equatable

```swift struct Color: Hashable { var r, g, b: UInt8 // Auto-synthesised: func hash(into:) and == } var palette: Set = [] palette.insert(Color(r:255,g:0,b:0)) ``` `Hashable` requiere `Equatable`; ambos se sintetizan automáticamente para estructuras sencillas.

Los protocolos con Self no se pueden usar directamente como existenciales

```swift // Before Swift 5.7: var shapes: [Equatable] = [] // ❌ Equatable has Self requirement // After Swift 5.7 with 'any': var boxes: [any Equatable] = [] // ⚠️ limited API ``` La palabra clave `any` permite explícitamente el encapsulado existencial.

Requisitos para la síntesis

La síntesis automática de `Equatable`/`Hashable`/`Comparable` requiere: • Que todas las propiedades almacenadas conformen al mismo protocolo • Que los casos de enumeración, incluidos los valores asociados, conformen ```swift struct Pair: Equatable { var a, b: T } // Equatable synthesised automatically ```

Sobrescritura personalizada de Equatable

```swift struct Person: Equatable { var id: UUID var name: String // Only compare by id, ignore name: static func == (lhs: Person, rhs: Person) -> Bool { lhs.id == rhs.id } } ```

Comprobación rápida

En un protocolo, ¿a qué hace referencia `Self`?

Repaso

Puntos clave: • `Self` = el tipo concreto que conforma al protocolo • `Equatable`, `Comparable` y `Hashable` usan `Self` • Swift los sintetiza automáticamente para estructuras y enumeraciones sencillas • `Self` en los tipos de retorno proporciona API que conserva el tipo • Los protocolos con requisitos de Self necesitan `any` para los existenciales (Swift 5.7+) Siguiente: principios del diseño orientado a protocolos.

Preguntas frecuentes

¿La lección «Requisitos de Self y diseño con Equatable» es gratis?

Sí — el texto completo de «Requisitos de Self y diseño con Equatable» 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 «Requisitos de Self y diseño con Equatable»?

Comprenda los protocolos que utilizan Self y cómo Equatable/Comparable lo aprovechan. 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 «Requisitos de Self y diseño con Equatable»?

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

  1. Composición de protocolos con &
  2. Conformidad condicional
  3. Requisitos de Self y diseño con Equatable
  4. Principios del diseño orientado a protocolos
← Volver a Swift Academy