Composizione dei protocolli
Combini i requisiti di più protocolli con &.
Composizione dei protocolli è 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.
Combinare i protocolli
A volte un valore deve soddisfare diversi protocolli contemporaneamente. Swift consente di comporre i protocolli con l'operatore &: SomeProtocol & AnotherProtocol.
protocol Named { var name: String { get } }
protocol Aged { var age: Int { get } }Un parametro composto
Un parametro tipizzato come Named & Aged accetta qualsiasi valore conforme a entrambi i protocolli.
protocol Named { var name: String { get } }
protocol Aged { var age: Int { get } }
struct Person: Named, Aged {
let name: String
let age: Int
}
func intro(_ x: Named & Aged) {
print(x.name + " is " + String(x.age))
}
intro(Person(name: "Sam", age: 28))Perché non usare l'ereditarietà?
La composizione consente di richiedere entrambi i protocolli nel punto di chiamata senza creare un nuovo protocollo combinato. Mantiene i protocolli piccoli e riutilizzabili.
protocol Drawable { func draw() -> String }
protocol Resizable { func resize(_ f: Double) -> String }
struct Icon: Drawable, Resizable {
func draw() -> String { "drawing" }
func resize(_ f: Double) -> String { "x" + String(f) }
}
func render(_ v: Drawable & Resizable) {
print(v.draw(), v.resize(2))
}
render(Icon())Tre o più protocolli
Può concatenare tutti i protocolli necessari utilizzando altri operatori &.
protocol A { func a() -> String }
protocol B { func b() -> String }
protocol C { func c() -> String }
struct X: A, B, C {
func a() -> String { "a" }
func b() -> String { "b" }
func c() -> String { "c" }
}
func use(_ v: A & B & C) { print(v.a(), v.b(), v.c()) }
use(X())Composizione con una classe
Può combinare un tipo classe con i protocolli: SomeClass & SomeProtocol richiede che il valore sia quella classe, o una sottoclasse, E che sia conforme al protocollo.
class Vehicle { var speed = 0 }
protocol Electric { var battery: Int { get } }
class Tesla: Vehicle, Electric { var battery = 100 }
func check(_ v: Vehicle & Electric) {
print(v.speed, v.battery)
}
check(Tesla())Restituire una composizione
Una funzione può restituire un tipo composto, garantendo al chiamante che il risultato sia conforme a tutti i protocolli elencati.
protocol Named { var name: String { get } }
protocol Aged { var age: Int { get } }
struct Person: Named, Aged { let name: String; let age: Int }
func makePerson() -> Named & Aged {
Person(name: "Eve", age: 22)
}
let p = makePerson()
print(p.name, p.age)typealias per una composizione
Assegni alla composizione un nome leggibile con typealias, così può riutilizzarla senza ripetere la catena di operatori &.
protocol Codable2 { func encode() -> String }
protocol Loggable { func log() -> String }
typealias Persistable = Codable2 & Loggable
struct Record: Persistable {
func encode() -> String { "data" }
func log() -> String { "logged" }
}
func save(_ r: Persistable) { print(r.encode(), r.log()) }
save(Record())Composizione nelle collezioni
Può memorizzare valori di tipo composto negli array, accedendo ai membri di tutti i protocolli per ogni elemento.
protocol Named { var name: String { get } }
protocol Aged { var age: Int { get } }
struct P: Named, Aged { let name: String; let age: Int }
let group: [Named & Aged] = [P(name: "A", age: 1), P(name: "B", age: 2)]
for g in group { print(g.name, g.age) }Composizione con i protocolli standard
La composizione è particolarmente utile con i protocolli delle librerie. Ad esempio, può richiedere sia CustomStringConvertible sia Equatable.
func report<T>(_ items: [T]) where T: CustomStringConvertible & Equatable {
for i in items { print(i.description) }
}
report([1, 2, 3])Protocolli vuoti come marcatori
La composizione può combinare un protocollo marcatore (senza requisiti) con uno funzionale per esprimere l'intento nel sistema dei tipi.
protocol Secure {}
protocol Sendable2 { func send() -> String }
struct Packet: Secure, Sendable2 {
func send() -> String { "sent securely" }
}
func transmit(_ p: Secure & Sendable2) { print(p.send()) }
transmit(Packet())Composizione e generici
La composizione (A & B) elimina il tipo concreto; i generici (<T: A & B>) lo preservano. Usi i generici quando è necessario correlare i tipi dei parametri e del valore restituito.
protocol A { func a() -> String }
protocol B { func b() -> String }
struct S: A, B { func a() -> String { "a" }; func b() -> String { "b" } }
func generic<T: A & B>(_ x: T) -> T { print(x.a(), x.b()); return x }
_ = generic(S())Verifica rapida
Verifichi la Sua comprensione della composizione dei protocolli.
Riepilogo
La composizione dei protocolli con & consente di richiedere contemporaneamente la conformità a più protocolli (e facoltativamente a una classe), senza definire un nuovo protocollo combinato. È possibile assegnare un nome alle composizioni con typealias, usarle nei parametri, nei valori restituiti e nelle raccolte, e comprendere la differenza tra composizione e generici nella conservazione dei tipi concreti.
Domande Frequenti
La lezione «Composizione dei protocolli» è gratuita?
Sì — il testo completo di «Composizione dei protocolli» è 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 «Composizione dei protocolli»?
Combini i requisiti di più protocolli con &. 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 «Composizione dei protocolli»?
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
- I protocolli come contratti
- Implementazioni predefinite nelle estensioni
- Composizione dei protocolli
- Conformità condizionale