0Pricing
Swift Academy · Lezione

I protocolli come contratti

Definisci contratti comportamentali indipendenti dai tipi.

I protocolli come contratti è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 1 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.

Che cos'è un protocollo?

Un protocollo definisce un modello di metodi, proprietà e altri requisiti che un tipo conforme deve implementare. È un contratto: qualsiasi tipo che lo adotta si impegna a fornire tutto ciò che il protocollo dichiara.

protocol Greetable {
    var name: String { get }
    func greet() -> String
}

Conformità a un protocollo

Un tipo è conforme adottando il protocollo e fornendo ogni requisito. Qui una struct soddisfa sia la proprietà name sia il metodo greet().

protocol Greetable {
    var name: String { get }
    func greet() -> String
}

struct Person: Greetable {
    let name: String
    func greet() -> String { "Hello, I am " + name }
}

let p = Person(name: "Ada")
print(p.greet())

Requisiti delle proprietà

I protocolli specificano se una proprietà deve essere disponibile in lettura ({ get }) oppure disponibile sia in lettura sia in scrittura ({ get set }). Una proprietà memorizzata o calcolata può soddisfare un requisito di sola lettura.

protocol Identifiable {
    var id: String { get }
}

struct User: Identifiable {
    let id: String
}

print(User(id: "u-1").id)

Requisiti dei metodi

I requisiti dei metodi indicano il nome, i parametri e il tipo restituito, ma non il corpo. I tipi conformi forniscono l'implementazione.

protocol Shape {
    func area() -> Double
}

struct Square: Shape {
    let side: Double
    func area() -> Double { side * side }
}

print(Square(side: 3).area())

Requisiti mutating

Per i tipi valore, i metodi che modificano self devono essere contrassegnati con mutating. Dichiari il requisito con mutating, così le struct possono soddisfarlo.

protocol Toggleable {
    mutating func toggle()
}

struct Switch: Toggleable {
    var isOn = false
    mutating func toggle() { isOn.toggle() }
}

var s = Switch()
s.toggle()
print(s.isOn)

I protocolli come tipi

Un protocollo è un tipo di prima classe. Può utilizzarlo per variabili, parametri e valori restituiti, accettando qualsiasi valore conforme.

protocol Animal { func sound() -> String }
struct Dog: Animal { func sound() -> String { "Woof" } }
struct Cat: Animal { func sound() -> String { "Meow" } }

let animals: [Animal] = [Dog(), Cat()]
for a in animals { print(a.sound()) }

Polimorfismo tramite i protocolli

La chiamata a un metodo del protocollo viene indirizzata al tipo concreto sottostante al valore. Questo consente di scrivere codice che funziona con molti tipi diversi attraverso un unico contratto.

protocol Describable { func describe() -> String }
struct Book: Describable { let t: String; func describe() -> String { "Book: " + t } }
struct Film: Describable { let t: String; func describe() -> String { "Film: " + t } }

func show(_ d: Describable) { print(d.describe()) }
show(Book(t: "Swift"))
show(Film(t: "Inception"))

Requisiti degli inizializzatori

I protocolli possono richiedere inizializzatori. Le classi devono contrassegnare l'implementazione con required, così anche le sottoclassi la forniscono.

protocol FromInt {
    init(value: Int)
}

struct Wrapper: FromInt {
    let value: Int
    init(value: Int) { self.value = value }
}

print(Wrapper(value: 42).value)

Ereditarietà dei protocolli

Un protocollo può ereditare da uno o più altri protocolli, aggiungendo ulteriori requisiti a quelli ereditati.

protocol Named { var name: String { get } }
protocol Aged: Named { var age: Int { get } }

struct Member: Aged {
    let name: String
    let age: Int
}

let m = Member(name: "Lin", age: 30)
print(m.name, m.age)

Protocolli solo per classi

Contrassegni un protocollo con AnyObject per limitare la conformità alle classi, una soluzione utile per requisiti con semantica di riferimento come la delega.

protocol Counter: AnyObject {
    var count: Int { get set }
}

class Box: Counter {
    var count = 0
}

let b = Box()
b.count = 5
print(b.count)

Verificare la conformità

Utilizzi is e as? per verificare in fase di esecuzione se un valore è conforme a un protocollo.

protocol Flyer { func fly() }
struct Bird: Flyer { func fly() { print("flap") } }
struct Rock {}

let things: [Any] = [Bird(), Rock()]
for t in things {
    if let f = t as? Flyer { f.fly() } else { print("grounded") }
}

Verifica rapida

Verifichi la comprensione dei requisiti dei protocolli.

Riepilogo

Ha imparato che un protocollo è un contratto: dichiara requisiti di proprietà, metodi, mutating e inizializzatori senza fornire implementazioni. I tipi sono conformi soddisfacendo ogni requisito; i protocolli possono essere utilizzati come tipi per il polimorfismo, possono ereditare da altri protocolli e possono essere limitati alle classi con AnyObject.

Domande Frequenti

La lezione «I protocolli come contratti» è gratuita?

Sì — il testo completo di «I protocolli come contratti» è 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 «I protocolli come contratti»?

Definisci contratti comportamentali indipendenti dai tipi. 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 1 di 4.

Quanto tempo richiede la lezione «I protocolli come contratti»?

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

  1. I protocolli come contratti
  2. Implementazioni predefinite nelle estensioni
  3. Composizione dei protocolli
  4. Conformità condizionale
← Torna a Swift Academy