Swift Academy · Lezione

Equatable sintetizzato

Ottieni == automaticamente e personalizzalo quando serve.

Equatable sintetizzato è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 4 lezioni in totale.

Che cos'è Equatable?

Equatable è il protocollo che fornisce a un tipo l'operatore ==. La conformità consente di confrontare due valori per verificarne l'uguaglianza e di usarli con contains, firstIndex e altro.

Conformità automatica

Per una struct le cui proprietà memorizzate sono tutte Equatable, Swift sintetizza automaticamente == per Lei: è sufficiente dichiarare la conformità:

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

Come funziona la sintesi

L'operatore == generato confronta ogni coppia di proprietà memorizzate. Tutte devono essere uguali perché i valori siano considerati uguali:

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)

Utilizzare == nelle collezioni

Equatable abilita molte operazioni sugli array:

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

Anche le enumerazioni sono Equatable

Anche per le enumerazioni viene sintetizzato Equatable. Le enumerazioni senza valori associati sono Equatable anche senza dichiararlo; con valori associati, dichiari la conformità e vengono confrontati anche i valori.

Enumerazione Equatable con valori associati

I valori associati partecipano al confronto:

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

Tipi annidati

La sintesi è compositiva: una struct che contiene membri Equatable può a sua volta essere sintetizzata:

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

Quando la sintesi non riesce

Se una qualsiasi proprietà memorizzata non è Equatable, la sintesi non è disponibile e deve scrivere personalmente == (come illustrato più avanti):

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

Le classi non vengono sintetizzate automaticamente

I tipi di riferimento non ricevono automaticamente == sintetizzato; deve implementarlo personalmente (confrontando l'identità o i campi):

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

!= è disponibile automaticamente

Quando == esiste, != viene derivato automaticamente come sua negazione:

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

Equatable nel codice generico

Equatable consente alle funzioni generiche di confrontare gli elementi: molti algoritmi lo richiedono:

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

Verifica rapida

Per quale tipo Swift sintetizza automaticamente == quando dichiara Equatable?

Riepilogo

Ha imparato a usare Equatable:

Equatable fornisce == (e != gratuitamente)
Le struct e le enumerazioni con membri Equatable ottengono == tramite sintesi
Abilita contains, firstIndex(of:) e così via
Le classi e i membri non Equatable richiedono un == scritto manualmente

Successivo: Hashable.

Domande Frequenti

La lezione «Equatable sintetizzato» è gratuita?

Sì — il testo completo di «Equatable sintetizzato» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 4 lezioni in totale.

Cosa imparerò in «Equatable sintetizzato»?

Ottieni == automaticamente e personalizzalo quando serve. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Swift Academy?

Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Equatable sintetizzato»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Swift Academy?

Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Swift Academy