Swift Academy · Lección

Equatable sintetizado

Obtenga == automáticamente y personalícelo cuando sea necesario.

Equatable sintetizado es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 1 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.

¿Qué es Equatable?

Equatable es el protocolo que proporciona el operador == a un tipo. Adoptarlo permite comparar dos valores para comprobar si son iguales y utilizarlos con contains, firstIndex y otras operaciones.

Conformidad automática

Para una estructura cuyas propiedades almacenadas son todas Equatable, Swift sintetiza == automáticamente; solo tiene que declarar la conformidad:

struct Point: Equatable {
    let x: Int
    let y: Int
}
print(Point(x: 1, y: 2) == Point(x: 1, y: 2))  // true
print(Point(x: 1, y: 2) == Point(x: 9, y: 2))  // false

Cómo funciona la síntesis

El operador == generado compara cada par de propiedades almacenadas. Todas deben ser iguales para que los valores sean iguales:

struct User: Equatable {
    let name: String
    let age: Int
}
let a = User(name: "Ann", age: 30)
let b = User(name: "Ann", age: 31)
print(a == b)  // false  (age differs)

Uso de == en colecciones

Equatable habilita muchas operaciones de arrays:

struct Tag: Equatable { let name: String }
let tags = [Tag(name: "a"), Tag(name: "b")]
print(tags.contains(Tag(name: "b")))        // true
print(tags.firstIndex(of: Tag(name: "a"))!) // 0

Las enumeraciones también son Equatable

Las enumeraciones también obtienen Equatable sintetizado. Las enumeraciones sin valores asociados son Equatable incluso sin declararlo; con valores asociados, declare la conformidad y esos valores también se compararán.

Enumeración Equatable con valores asociados

Los valores asociados participan en la comparación:

enum Status: Equatable {
    case active
    case error(code: Int)
}
print(Status.error(code: 404) == Status.error(code: 404))  // true
print(Status.error(code: 404) == Status.error(code: 500))  // false

Tipos anidados

La síntesis se compone: una estructura que contiene miembros Equatable también puede sintetizarse:

struct Line: Equatable {
    let start: Int
    let end: Int
}
struct Shape: Equatable {
    let lines: [Line]
}
print(Shape(lines: [Line(start: 0, end: 1)]) == Shape(lines: [Line(start: 0, end: 1)]))  // true

Cuándo falla la síntesis

Si alguna propiedad almacenada no es Equatable, la síntesis no está disponible y debe escribir == manualmente (lo veremos más adelante):

struct Box: Equatable {
    let id: Int
    static func == (l: Box, r: Box) -> Bool { l.id == r.id }
}
print(Box(id: 1) == Box(id: 1))  // true

Las clases no se sintetizan automáticamente

Los tipos de referencia no obtienen == sintetizado; debe implementarlo usted (comparando la identidad o los campos):

final class Account: Equatable {
    let id: Int
    init(id: Int) { self.id = id }
    static func == (l: Account, r: Account) -> Bool { l.id == r.id }
}
print(Account(id: 7) == Account(id: 7))  // true

!= se obtiene automáticamente

Una vez que existe ==, != se deriva automáticamente como su negación:

struct Color: Equatable { let hex: String }
print(Color(hex: "#fff") != Color(hex: "#000"))  // true

Equatable en código genérico

Equatable permite que las funciones genéricas comparen elementos; muchos algoritmos lo requieren:

func allSame<T: Equatable>(_ xs: [T]) -> Bool {
    guard let first = xs.first else { return true }
    return xs.allSatisfy { $0 == first }
}
print(allSame([2, 2, 2]))  // true
print(allSame(["a", "b"]))  // false

Comprobación rápida

¿Para qué tipo sintetiza Swift automáticamente == cuando declara Equatable?

Resumen

Ha aprendido Equatable:

Equatable proporciona == (y != automáticamente)
Las estructuras y enumeraciones con miembros Equatable obtienen == sintetizado
Habilita contains, firstIndex(of:), etc.
Las clases y los miembros que no son Equatable requieren un == manual

Siguiente: Hashable.

Preguntas frecuentes

¿La lección «Equatable sintetizado» es gratis?

Sí — el texto completo de «Equatable sintetizado» 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 «Equatable sintetizado»?

Obtenga == automáticamente y personalícelo cuando sea necesario. 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 1 de 4.

¿Cuánto tiempo toma la lección «Equatable sintetizado»?

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