Swift Academy · Lekcja

Syntezowane Equatable

Automatyczne uzyskanie == i dostosowanie go w razie potrzeby.

Syntezowane Equatable to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Swift Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Swift Academy zawiera 4 lekcji w sumie.

Czym jest Equatable

Protokół Equatable udostępnia typowi operator ==. Zapewnienie zgodności pozwala porównywać dwie wartości pod kątem równości oraz używać ich z contains, firstIndex i innymi operacjami.

Automatyczne zapewnianie zgodności

W przypadku struktury, której wszystkie przechowywane właściwości są zgodne z Equatable, Swift automatycznie generuje dla niej operator == — wystarczy zadeklarować zgodność:

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

Jak działa automatyczne generowanie

Wygenerowany operator == porównuje parami wszystkie przechowywane właściwości. Wszystkie muszą być równe, aby wartości były równe:

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)

Używanie == w kolekcjach

Equatable udostępnia wiele operacji na tablicach:

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

Typy wyliczeniowe również są Equatable

Typy wyliczeniowe również otrzymują automatycznie generowaną zgodność z Equatable. Typy wyliczeniowe bez wartości skojarzonych są zgodne z Equatable nawet bez deklarowania tej zgodności; w przypadku wartości skojarzonych należy zadeklarować zgodność, a wartości te również będą porównywane.

Typ wyliczeniowy Equatable z wartościami skojarzonymi

Wartości skojarzone uczestniczą w porównaniu:

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

Typy zagnieżdżone

Automatyczne generowanie jest kompozycyjne: strukturę zawierającą elementy zgodne z Equatable również można obsłużyć automatycznie:

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

Kiedy automatyczne generowanie się nie powiedzie

Jeśli którakolwiek przechowywana właściwość nie jest zgodna z Equatable, automatyczne generowanie jest niedostępne i trzeba samodzielnie napisać == (zostanie to omówione później):

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

Klasy nie otrzymują automatycznie generowanej zgodności

Typy referencyjne nie otrzymują automatycznie generowanego operatora ==; trzeba zaimplementować go samodzielnie (porównując tożsamość lub pola):

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

!= otrzymuje się automatycznie

Gdy istnieje już ==, operator != jest automatycznie wyprowadzany jako jego negacja:

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

Equatable w kodzie generycznym

Equatable pozwala funkcjom generycznym porównywać elementy — wymaga tego wiele algorytmów:

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

Szybkie sprawdzenie

Dla którego typu Swift automatycznie wygeneruje == po zadeklarowaniu Equatable?

Podsumowanie

Poznali Państwo Equatable:

Equatable udostępnia == (oraz dostępny automatycznie operator !=)
Struktury i typy wyliczeniowe zawierające elementy zgodne z Equatable otrzymują automatycznie wygenerowany operator ==
Umożliwia używanie contains, firstIndex(of:) itd.
Klasy i elementy niezgodne z Equatable wymagają ręcznej implementacji ==

Następnie: Hashable.

Często zadawane pytania

Czy lekcja „Syntezowane Equatable” jest bezpłatna?

Tak — pełny tekst „Syntezowane Equatable” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Swift Academy, przejdź na CoddyKit PRO. Kurs Swift Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Syntezowane Equatable”?

Automatyczne uzyskanie == i dostosowanie go w razie potrzeby. Ćwiczysz Swift Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Swift Academy?

Nie wymagamy żadnego doświadczenia. Swift Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Syntezowane Equatable”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Swift Academy?

Tak. Każda lekcja Swift Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Swift Academy