Swift Academy · Lekcja

Ograniczanie typów powiązanych

Ograniczanie typów powiązanych w kontekstach generycznych.

Ograniczanie typów powiązanych 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.

Podsumowanie typów skojarzonych

Protokół może zadeklarować typ skojarzony za pomocą associatedtype — jest to symbol zastępczy, którego wartość określa typ zgodny z protokołem. Klasycznym przykładem jest Element w protokole kontenera.

protocol Container {
    associatedtype Item
    var count: Int { get }
    func item(at i: Int) -> Item
}

Zgodność z konkretnym typem

Typ zgodny z protokołem ustala typ skojarzony, który często jest wywnioskowywany na podstawie sposobu użycia tego typu.

protocol Container {
    associatedtype Item
    func item(at i: Int) -> Item
}
struct IntBox: Container {
    let values: [Int]
    func item(at i: Int) -> Int { values[i] }
}
print(IntBox(values: [10, 20]).item(at: 1))

Ograniczanie typu skojarzonego

Ograniczenie można dodać bezpośrednio w deklaracji: associatedtype Item: Comparable wymusza, aby typ elementu każdego typu zgodnego z protokołem obsługiwał porównywanie.

protocol Sorted {
    associatedtype Item: Comparable
    var items: [Item] { get }
}
struct Nums: Sorted { let items: [Int] }
print(Nums(items: [3, 1, 2]).items.sorted())

Korzystanie z ograniczenia

Gdy typ skojarzony jest ograniczony, rozszerzenia protokołu mogą polegać na udostępnianej przez niego funkcjonalności.

protocol Sorted {
    associatedtype Item: Comparable
    var items: [Item] { get }
}
extension Sorted {
    var smallest: Item? { items.min() }
}
struct Nums: Sorted { let items: [Int] }
print(Nums(items: [5, 2, 8]).smallest!)

where przy associatedtype

Swift pozwala również umieścić klauzulę where przy typie skojarzonym, aby powiązać go z innym typem skojarzonym lub typem zagnieżdżonym.

protocol Sequence2 {
    associatedtype Element
    associatedtype Iterator: IteratorProtocol where Iterator.Element == Element
}

Ograniczenie do innego protokołu

Można wymagać, aby typ skojarzony był zgodny ze zdefiniowanym przez Państwa protokołem, tworząc kolejne warstwy funkcjonalności.

protocol HasName { var name: String { get } }
protocol Registry {
    associatedtype Entry: HasName
    var entries: [Entry] { get }
}
struct User: HasName { let name: String }
struct Users: Registry { let entries: [User] }
print(Users(entries: [User(name: "Ada")]).entries[0].name)

Wiele typów skojarzonych

Protokół może deklarować kilka typów skojarzonych, z których każdy jest niezależnie ograniczony.

protocol Mapping {
    associatedtype Key: Hashable
    associatedtype Value
    func value(for k: Key) -> Value?
}
struct Phonebook: Mapping {
    let data: [String: Int]
    func value(for k: String) -> Int? { data[k] }
}
print(Phonebook(data: ["x": 1]).value(for: "x")!)

Domyślny typ skojarzony

Typowi skojarzonemu można przypisać wartość domyślną za pomocą =. Zostanie ona użyta, gdy typ zgodny z protokołem nie określi tego typu w inny sposób.

protocol Producer {
    associatedtype Output = String
    func make() -> Output
}
struct Hello: Producer {
    func make() -> String { "hi" }
}
print(Hello().make())

Ograniczenia umożliwiają tworzenie algorytmów generycznych

Dzięki ograniczonemu typowi skojarzonemu rozszerzenie protokołu może implementować rzeczywiste algorytmy współdzielone przez wszystkie typy zgodne z protokołem.

protocol Scored {
    associatedtype Score: Comparable
    var scores: [Score] { get }
}
extension Scored {
    var best: Score? { scores.max() }
}
struct Game: Scored { let scores: [Int] }
print(Game(scores: [10, 40, 25]).best!)

Ograniczenia równości typów w rozszerzeniach

Poza protokołem można dodatkowo ograniczyć typ skojarzony podczas rozszerzania protokołu.

protocol Box2 {
    associatedtype Content
    var content: Content { get }
}
extension Box2 where Content == Int {
    var doubled: Int { content * 2 }
}
struct IB: Box2 { let content: Int }
print(IB(content: 7).doubled)

Po co wprowadzać ograniczenia?

Ograniczanie typów skojarzonych pozwala protokołom zachować uniwersalność, a jednocześnie zapewniać dużą funkcjonalność: ograniczenie jest obietnicą, na której mogą polegać rozszerzenie i wywołujący.

protocol Listy {
    associatedtype E: Equatable
    var elements: [E] { get }
}
extension Listy {
    func has(_ x: E) -> Bool { elements.contains(x) }
}
struct L: Listy { let elements: [String] }
print(L(elements: ["a", "b"]).has("b"))

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat ograniczania typów skojarzonych.

Podsumowanie

Typy skojarzone można ograniczać bezpośrednio (associatedtype Item: Comparable), wiązać za pomocą klauzul where, wymagać ich zgodności z protokołem, określać ich wartości domyślne za pomocą =, deklarować wiele typów skojarzonych oraz doprecyzowywać je w rozszerzeniach. Ograniczenia pozwalają rozszerzeniom protokołów implementować współdzielone algorytmy bezpieczne typowo.

Często zadawane pytania

Czy lekcja „Ograniczanie typów powiązanych” jest bezpłatna?

Tak — pełny tekst „Ograniczanie typów powiązanych” 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 „Ograniczanie typów powiązanych”?

Ograniczanie typów powiązanych w kontekstach generycznych. Ć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 „Ograniczanie typów powiązanych”?

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