Swift Academy · Lezione

Vincoli sui tipi associati

Limita i tipi associati nei contesti generici.

Vincoli sui tipi associati è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 4 lezioni in totale.

Riepilogo dei tipi associati

Un protocollo può dichiarare un tipo associato con associatedtype, ovvero un segnaposto che il tipo conforme deve specificare. Element in un protocollo per contenitori è l'esempio classico.

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

Conformità con un tipo concreto

Un tipo conforme fissa il tipo associato, spesso dedotto dal modo in cui viene utilizzato.

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

Vincolare il tipo associato

Aggiunga un vincolo direttamente nella dichiarazione: associatedtype Item: Comparable obbliga il tipo dell'elemento di ogni tipo conforme a supportare il confronto.

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

Utilizzare il vincolo

Poiché il tipo associato è vincolato, le estensioni del protocollo possono fare affidamento su questa capacità.

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 su associatedtype

Swift consente anche di applicare una clausola where a un tipo associato per collegarlo a un altro tipo associato o a un tipo annidato.

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

Vincolo su un altro protocollo

È possibile richiedere che un tipo associato sia conforme a un protocollo definito da Lei, aggiungendo livelli di comportamento.

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)

Più tipi associati

Un protocollo può dichiarare diversi tipi associati, ciascuno con i propri vincoli.

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

Tipo associato predefinito

È possibile assegnare un valore predefinito a un tipo associato con =, utilizzato quando un tipo conforme non ne specifica altrimenti il tipo.

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

I vincoli abilitano gli algoritmi generici

Con un tipo associato vincolato, un'estensione del protocollo può implementare algoritmi reali condivisi da tutti i tipi conformi.

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

Vincoli di uguaglianza tra tipi nelle estensioni

Al di fuori del protocollo, è possibile vincolare ulteriormente il tipo associato quando si estende il protocollo.

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)

Perché aggiungere vincoli

Vincolare i tipi associati permette ai protocolli di rimanere generici ma potenti: il vincolo è una garanzia su cui l'estensione e il codice chiamante possono fare affidamento.

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

Verifica rapida

Verifichi la Sua comprensione dei vincoli sui tipi associati.

Riepilogo

È possibile vincolare direttamente i tipi associati (associatedtype Item: Comparable), collegarli con clausole where, richiedere la conformità a un protocollo, assegnare valori predefiniti con =, dichiarare più tipi associati e perfezionarli nelle estensioni. I vincoli consentono alle estensioni dei protocolli di implementare algoritmi condivisi e sicuri dal punto di vista dei tipi.

Domande Frequenti

La lezione «Vincoli sui tipi associati» è gratuita?

Sì — il testo completo di «Vincoli sui tipi associati» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 4 lezioni in totale.

Cosa imparerò in «Vincoli sui tipi associati»?

Limita i tipi associati nei contesti generici. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Swift Academy?

Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Vincoli sui tipi associati»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Swift Academy?

Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Swift Academy