Swift Academy · Lekcja

Wymagania Self i projektowanie Equatable

Protokoły używające Self oraz sposób, w jaki Equatable i Comparable wykorzystują te wymagania.

Wymagania Self i projektowanie Equatable to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 3 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.

Wprowadzenie

`Self` w protokole oznacza konkretny typ, który jest z nim zgodny. Dzięki temu protokoły takie jak `Equatable` i `Comparable` mogą bezpiecznie działać z typami heterogenicznymi.

Self jako typ parametru

```swift protocol Equatable { static func == (lhs: Self, rhs: Self) -> Bool } ``` `Self` oznacza, że oba parametry muszą mieć *ten sam* konkretny typ. Za pomocą tego protokołu nie można porównać `Int` z `String`.

Zgodność z Equatable

```swift struct Point: Equatable { var x: Double var y: Double // Auto-synthesised: // static func == (lhs: Point, rhs: Point) -> Bool // { lhs.x == rhs.x && lhs.y == rhs.y } } print(Point(x:1,y:2) == Point(x:1,y:2)) // true ```

Comparable z Self

```swift struct Version: Comparable { let major, minor, patch: Int static func < (lhs: Version, rhs: Version) -> Bool { (lhs.major, lhs.minor, lhs.patch) < (rhs.major, rhs.minor, rhs.patch) } } let v1 = Version(major:1,minor:2,patch:0) let v2 = Version(major:2,minor:0,patch:0) print(v1 < v2) // true ```

Self jako typ zwracany

```swift protocol Clonable { func clone() -> Self } class Animal: Clonable { var name: String = "" required init() {} func clone() -> Self { type(of: self).init() } } ``` `Self` w typie zwracanym oznacza, że podklasy zwracają własny typ, a nie `Animal`.

Protokół z wymaganiem Self (PAT)

```swift protocol Scalable { func scaled(by factor: Double) -> Self } struct Size: Scalable { var w, h: Double func scaled(by f: Double) -> Size { Size(w: w*f, h: h*f) } } ```

Hashable: Self + Equatable

```swift struct Color: Hashable { var r, g, b: UInt8 // Auto-synthesised: func hash(into:) and == } var palette: Set = [] palette.insert(Color(r:255,g:0,b:0)) ``` `Hashable` wymaga `Equatable` — w przypadku prostych struktur oba protokoły są implementowane automatycznie.

Protokoły z Self nie mogą być bezpośrednio używane jako typy egzystencjalne

```swift // Before Swift 5.7: var shapes: [Equatable] = [] // ❌ Equatable has Self requirement // After Swift 5.7 with 'any': var boxes: [any Equatable] = [] // ⚠️ limited API ``` Słowo kluczowe `any` jawnie włącza opakowywanie w typ egzystencjalny.

Wymagania automatycznej syntezy

Automatyczna synteza `Equatable`/`Hashable`/`Comparable` wymaga: • Wszystkie przechowywane właściwości muszą być zgodne z tym samym protokołem • Przypadki wyliczeń, w tym ich wartości powiązane, muszą być zgodne z tym protokołem ```swift struct Pair: Equatable { var a, b: T } // Equatable synthesised automatically ```

Niestandardowa implementacja Equatable

```swift struct Person: Equatable { var id: UUID var name: String // Only compare by id, ignore name: static func == (lhs: Person, rhs: Person) -> Bool { lhs.id == rhs.id } } ```

Szybkie sprawdzenie

Do czego odnosi się `Self` w protokole?

Podsumowanie

Najważniejsze informacje: • `Self` = konkretny typ zgodny z protokołem • `Equatable`, `Comparable` i `Hashable` używają `Self` • Swift automatycznie implementuje te protokoły dla prostych struktur i wyliczeń • `Self` w typach zwracanych pozwala tworzyć API zachowujące typ • Protokoły z wymaganiami Self potrzebują `any` jako typów egzystencjalnych (Swift 5.7+) Dalej: zasady projektowania zorientowanego protokołowo.

Często zadawane pytania

Czy lekcja „Wymagania Self i projektowanie Equatable” jest bezpłatna?

Tak — pełny tekst „Wymagania Self i projektowanie 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 „Wymagania Self i projektowanie Equatable”?

Protokoły używające Self oraz sposób, w jaki Equatable i Comparable wykorzystują te wymagania. Ć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 3 z 4.

Ile czasu zajmuje lekcja „Wymagania Self i projektowanie 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

Kompozycja protokołów za pomocą &
Warunkowa zgodność z protokołem
Wymagania Self i projektowanie Equatable
Zasady projektowania zorientowanego na protokoły

← Powrót do Swift Academy