Swift Academy · Lección

Semántica de igualdad personalizada

Implemente reglas de igualdad correctas para el dominio.

Semántica de igualdad personalizada 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.

Cuándo el == predeterminado no es correcto

El == sintetizado compara todas las propiedades almacenadas. A veces es demasiado estricto (solo le interesa un id) o demasiado permisivo. En ese caso, debe escribir == usted mismo.

Igualdad basada en la identidad

Considere dos registros iguales cuando sus ids coincidan, ignorando los demás campos:

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

Igualdad sin distinguir mayúsculas y minúsculas

Normalice los valores antes de compararlos:

struct Username: Equatable {
    let raw: String
    static func == (l: Username, r: Username) -> Bool {
        l.raw.lowercased() == r.raw.lowercased()
    }
}
print(Username(raw: "Ann") == Username(raw: "ANN"))  // true

Mantener Hashable coherente

Si personaliza ==, DEBE actualizar hash(into:) para que utilice los mismos campos; de lo contrario, los valores iguales podrían producir hashes distintos y romper los Sets.

Coincidencia entre == y hash(into:)

Ambos utilizan únicamente id, por lo que se mantienen coherentes:

struct User: Hashable {
    let id: Int
    var name: String
    static func == (l: User, r: User) -> Bool { l.id == r.id }
    func hash(into h: inout Hasher) { h.combine(id) }
}
print(Set([User(id: 1, name: "A"), User(id: 1, name: "B")]).count)  // 1

Igualdad que ignora una caché

Excluya de la comparación los campos derivados o almacenados en caché:

struct Doc: Equatable {
    let text: String
    var cachedWordCount: Int
    static func == (l: Doc, r: Doc) -> Bool { l.text == r.text }
}
let a = Doc(text: "hi", cachedWordCount: 1)
let b = Doc(text: "hi", cachedWordCount: 999)
print(a == b)  // true

Igualdad tolerante de números de coma flotante

Compare los valores double dentro de un épsilon en lugar de compararlos exactamente:

struct Measure: Equatable {
    let value: Double
    static func == (l: Measure, r: Measure) -> Bool {
        abs(l.value - r.value) < 0.0001
    }
}
print(Measure(value: 0.1 + 0.2) == Measure(value: 0.3))  // true

Igualdad basada en un subconjunto de campos

Compare un subconjunto significativo para definir la igualdad del dominio:

struct Card: Equatable {
    let rank: Int
    let suit: String
    let isFaceUp: Bool   // display state, not identity
    static func == (l: Card, r: Card) -> Bool {
        l.rank == r.rank && l.suit == r.suit
    }
}
print(Card(rank: 1, suit: "H", isFaceUp: true) == Card(rank: 1, suit: "H", isFaceUp: false))  // true

Respete las leyes de Equatable

El == personalizado debe seguir siendo reflexivo (a == a), simétrico (a == b implica b == a) y transitivo. Incumplir estas propiedades confunde a las colecciones y los algoritmos.

Una implementación simétrica

Comparar formas normalizadas mantiene intacta la simetría:

struct Email: Equatable {
    let address: String
    static func == (l: Email, r: Email) -> Bool {
        l.address.lowercased() == r.address.lowercased()
    }
}
let x = Email(address: "A@x.com")
let y = Email(address: "a@X.com")
print(x == y, y == x)  // true true

Igualdad personalizada en un Set

Como la igualdad y el hash basados únicamente en id coinciden, el Set trata los valores con el mismo id como uno solo:

struct Item: Hashable {
    let id: Int
    var note: String
    static func == (l: Item, r: Item) -> Bool { l.id == r.id }
    func hash(into h: inout Hasher) { h.combine(id) }
}
let s: Set<Item> = [Item(id: 1, note: "x"), Item(id: 1, note: "y")]
print(s.count)  // 1

Comprobación rápida

Después de escribir un == personalizado que utiliza solo algunos campos, ¿qué más debe hacer?

Resumen

Ha aprendido sobre la igualdad personalizada:

Escriba su propio == cuando la comparación predeterminada de toda la estructura no sea correcta
Casos comunes: solo por id, sin distinguir mayúsculas y minúsculas, valores de coma flotante con épsilon e ignorar cachés
Mantenga hash(into:) coherente utilizando los mismos campos
Mantenga las propiedades reflexiva, simétrica y transitiva

¡Curso completado! Siguiente: CustomStringConvertible y Mirror.

Preguntas frecuentes

¿La lección «Semántica de igualdad personalizada» es gratis?

Sí — el texto completo de «Semántica de igualdad personalizada» 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 «Semántica de igualdad personalizada»?

Implemente reglas de igualdad correctas para el dominio. 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 «Semántica de igualdad personalizada»?

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