0Pricing
Swift Academy · Lekcja

Warunkowa zgodność z protokołem

Warunkowe zapewnianie zgodności typów generycznych z protokołami za pomocą klauzul where.

Warunkowa zgodność z protokołem to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 2 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

Warunkowa zgodność pozwala typowi generycznemu być zgodnym z protokołem tylko wtedy, gdy jego parametr lub parametry typu spełniają określone ograniczenia. Jest to jeden z fundamentów wyrazistego systemu typów języka Swift.

Podstawowa warunkowa zgodność

```swift extension Array: Equatable where Element: Equatable { // Array is Equatable only when Element is Equatable } let a = [1,2,3] let b = [1,2,3] print(a == b) // true — works because Int is Equatable ```

Własny typ generyczny

```swift struct Box { var value: T } extension Box: Equatable where T: Equatable { static func == (lhs: Box, rhs: Box) -> Bool { lhs.value == rhs.value } } print(Box(value: 42) == Box(value: 42)) // true ```

Warunkowa zgodność z Hashable

```swift extension Box: Hashable where T: Hashable { func hash(into hasher: inout Hasher) { hasher.combine(value) } } // Box is Hashable; Box is not ```

Warunkowa zgodność z Codable

```swift extension Box: Codable where T: Codable {} let box = Box(value: "hello") let data = try JSONEncoder().encode(box) // works — String is Codable ```

Klauzule where w rozszerzeniach

```swift extension Collection where Element == Int { var sum: Int { reduce(0, +) } } print([1,2,3,4].sum) // 10 // This extension only applies to collections of Int ```

Wiele ograniczeń

```swift extension Dictionary where Key: Comparable, Value: Equatable { func sortedByKey() -> [(Key, Value)] { sorted { $0.key < $1.key } } } ```

Warunkowa zgodność z protokołem

```swift protocol Printable { func prettyPrint() } extension Optional: Printable where Wrapped: Printable { func prettyPrint() { switch self { case .none: print("nil") case .some(let v): v.prettyPrint() } } } ```

Używanie warunkowej zgodności

```swift let opt: Int? = 42 // If Int conformed to Printable: // opt.prettyPrint() // "42" // Standard usage: let nums = Optional([1,2,3]) // [1,2,3]? if let arr = nums, arr == [1,2,3] { ... } // Equatable via conditional ```

Ostrzeżenie dotyczące retroaktywnej zgodności

Swift 5.7+ wyświetla ostrzeżenie dotyczące retroaktywnej zgodności (dodawania zgodności do typów z innego modułu): ```swift extension String: SomeThirdPartyProtocol {} // ⚠️ retroactive ``` Jeśli jest to zamierzone, należy jawnie oznaczyć taką zgodność za pomocą `@retroactive`.

Szybkie sprawdzenie

Jakie słowo kluczowe wprowadza warunek w rozszerzeniu z warunkową zgodnością?

Podsumowanie

Najważniejsze informacje: • `extension T: Protocol where Param: Constraint` — warunkowa zgodność • Tablice, Optional, Result itd. używają tego mechanizmu dla Equatable, Hashable i Codable • Własne typy generyczne mogą działać tak samo • `where Element == Int` ogranicza typ do konkretnych typów • W Swift 5.7+ retroaktywne zgodności wymagają `@retroactive` Dalej: wymagania Self.

Często zadawane pytania

Czy lekcja „Warunkowa zgodność z protokołem” jest bezpłatna?

Tak — pełny tekst „Warunkowa zgodność z protokołem” 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 „Warunkowa zgodność z protokołem”?

Warunkowe zapewnianie zgodności typów generycznych z protokołami za pomocą klauzul where. Ć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 2 z 4.

Ile czasu zajmuje lekcja „Warunkowa zgodność z protokołem”?

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

  1. Kompozycja protokołów za pomocą &
  2. Warunkowa zgodność z protokołem
  3. Wymagania Self i projektowanie Equatable
  4. Zasady projektowania zorientowanego na protokoły
← Powrót do Swift Academy