Swift Academy · Lektion

Synthetisiertes Equatable

Erhalten Sie == automatisch und passen Sie es bei Bedarf an.

Synthetisiertes Equatable ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Swift Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist Equatable?

Equatable ist das Protokoll, das einem Typ den Operator == zur Verfügung stellt. Durch die Konformität können Sie zwei Werte auf Gleichheit prüfen und sie mit contains, firstIndex und weiteren Methoden verwenden.

Automatische Konformität

Bei einer Struktur, deren gespeicherte Eigenschaften alle Equatable sind, synthetisiert Swift == für Sie — deklarieren Sie einfach die Konformität:

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

So funktioniert die Synthese

Das generierte == vergleicht jedes Paar gespeicherter Eigenschaften miteinander. Alle müssen gleich sein, damit die Werte gleich sind:

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)

== in Collections verwenden

Equatable ermöglicht viele Array-Operationen:

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

Auch Enums sind Equatable

Auch für Enums wird Equatable synthetisiert. Enums ohne zugehörige Werte sind auch ohne entsprechende Deklaration Equatable; bei zugehörigen Werten müssen Sie die Konformität deklarieren, und auch diese Werte werden verglichen.

Equatable-Enum mit zugehörigen Werten

Zugehörige Werte werden in den Vergleich einbezogen:

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

Verschachtelte Typen

Die Synthese setzt sich zusammen: Eine Struktur, die Equatable-Mitglieder enthält, kann selbst synthetisiert werden:

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

Wenn die Synthese fehlschlägt

Wenn eine gespeicherte Eigenschaft nicht Equatable ist, steht die Synthese nicht zur Verfügung, und Sie müssen == selbst schreiben (das wird später behandelt):

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

Für Klassen wird nicht automatisch synthetisiert

Referenztypen erhalten kein synthetisiertes ==; Sie müssen es implementieren (durch Vergleich der Identität oder der Eigenschaften):

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

!= gibt es automatisch dazu

Sobald == vorhanden ist, wird != automatisch als Negation davon abgeleitet:

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

Equatable in generischem Code

Equatable ermöglicht es generischen Funktionen, Elemente zu vergleichen — viele Algorithmen setzen dies voraus:

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

Schnelltest

Für welchen Typ synthetisiert Swift == automatisch, wenn Sie Equatable deklarieren?

Zusammenfassung

Sie haben Equatable kennengelernt:

Equatable stellt == (und kostenlos !=) bereit
Für Strukturen und Enums mit Equatable-Mitgliedern wird == synthetisiert
Ermöglicht contains, firstIndex(of:) usw.
Klassen und nicht-Equatable-Mitglieder erfordern ein manuell implementiertes ==

Als Nächstes: Hashable.

Häufig gestellte Fragen

Ist die Lektion „Synthetisiertes Equatable“ kostenlos?

Ja — der vollständige Text von „Synthetisiertes Equatable“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Swift Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Synthetisiertes Equatable“?

Erhalten Sie == automatisch und passen Sie es bei Bedarf an. Du übst Swift Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Swift Academy zu starten?

Keine Vorkenntnisse erforderlich. Swift Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Synthetisiertes Equatable“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Swift Academy-Lektion Code schreiben und ausführen?

Ja. Jede Swift Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Swift Academy