Swift Academy · Oppitunti

Assosioitujen tyyppien rajoittaminen

Rajoita assosioituja tyyppejä geneerisissä konteksteissa.

Oppitunti 3/413 vaihetta

Assosioitujen tyyppien rajoittaminen on ilmainen Swift Academy-oppitunti CoddyKitissä. Tämä on oppitunti 3/4. Voit lukea tästä oppimispolusta kokonaan mitkä tahansa 3 oppituntia ilmaiseksi — sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä käytännön harjoittelun sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Oppitunti kuuluu Swift Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Swift Academy-kurssilla on yhteensä 4 oppituntia.

Assosioitujen tyyppien kertaus

Protokolla voi ilmoittaa assosioidun tyypin associatedtype-määrittelyllä. Se on paikanvaraaja, jonka protokollaa noudattava tyyppi täyttää. Säilöprotokollan Element on klassinen esimerkki.

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

Noudattaminen konkreettisella tyypillä

Protokollaa noudattava tyyppi määrittää assosioidun tyypin, joka päätellään usein sen käyttötavasta.

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))

Assosioidun tyypin rajoittaminen

Lisätkää rajoite suoraan määrittelyyn: associatedtype Item: Comparable pakottaa jokaisen protokollaa noudattavan tyypin Item-tyypin tukemaan vertailua.

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

Rajoitteen käyttäminen

Koska assosioitua tyyppiä on rajoitettu, protokollalaajennukset voivat luottaa tähän kyvykkyyteen.

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 associatedtype-määrittelyssä

Swift sallii myös where-lauseen assosioidulle tyypille, jolloin sen voi yhdistää toiseen assosioituun tyyppiin tai sisäkkäiseen tyyppiin.

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

Rajoittaminen toiseen protokollaan

Assosioidulta tyypiltä voidaan vaatia itse määrittelemänne protokollan noudattamista, jolloin toiminnallisuutta voidaan kerrostaa.

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)

Useita assosioituja tyyppejä

Protokolla voi ilmoittaa useita assosioituja tyyppejä, joista kutakin voidaan rajoittaa erikseen.

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")!)

Oletusarvoinen assosioitu tyyppi

Assosioidulle tyypille voi antaa oletusarvon =-operaattorilla. Sitä käytetään, jos protokollaa noudattava tyyppi ei määritä tyyppiä muulla tavoin.

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

Rajoitteet mahdollistavat geneeriset algoritmit

Kun assosioitua tyyppiä on rajoitettu, protokollalaajennus voi toteuttaa kaikille protokollaa noudattaville tyypeille yhteisiä todellisia algoritmeja.

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!)

Saman tyypin rajoitteet laajennuksissa

Protokollan ulkopuolella voitte rajoittaa assosioitua tyyppiä edelleen protokollaa laajennettaessa.

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)

Miksi rajoittaa?

Assosioitujen tyyppien rajoittaminen pitää protokollat geneerisinä mutta tehokkaina: rajoite on lupaus, johon laajennus ja kutsuva koodi voivat luottaa.

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"))

Pikatesti

Testatkaa, kuinka hyvin ymmärrätte assosioitujen tyyppien rajoittamisen.

Vastaa interaktiivisessa oppitunnissa

Kertaus

Voitte rajoittaa assosioituja tyyppejä suoraan (associatedtype Item: Comparable), yhdistää niitä where-lauseilla, vaatia protokollan noudattamista, antaa oletusarvoja =-operaattorilla, ilmoittaa useita assosioituja tyyppejä ja tarkentaa niitä laajennuksissa. Rajoitteiden avulla protokollalaajennukset voivat toteuttaa yhteisiä, tyyppiturvallisia algoritmeja.

Aloita maksutta

Opi Swift tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 122
Oppitunnit: 409

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Assosioitujen tyyppien rajoittaminen” ilmainen?

Kyllä — voit lukea täällä verkossa kokonaan ilmaiseksi mitkä tahansa Swift Academy-oppimispolun 3 oppituntia, myös oppitunnin “Assosioitujen tyyppien rajoittaminen”. Sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä interaktiiviset harjoitukset sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Swift Academy-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Assosioitujen tyyppien rajoittaminen”?

Rajoita assosioituja tyyppejä geneerisissä konteksteissa. Harjoittelet Swift Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Swift Academy-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Swift Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 3/4.

Kuinka kauan ”Assosioitujen tyyppien rajoittaminen”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Swift Academy-oppitunnilla?

Kyllä. Jokainen Swift Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

← Takaisin: Swift Academy