Swift Academy · Lezione

Requisiti Self e progettazione Equatable

I protocolli che usano Self e il modo in cui Equatable e Comparable ne sfruttano le capacità.

Requisiti Self e progettazione Equatable è 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.

Benvenuto

In un protocollo, `Self` indica il tipo concreto che vi si conforma. Ciò consente a protocolli come `Equatable` e `Comparable` di lavorare in modo sicuro con tipi eterogenei.

Self come tipo di parametro

```swift protocol Equatable { static func == (lhs: Self, rhs: Self) -> Bool } ``` `Self` significa che entrambi i parametri devono avere lo *stesso* tipo concreto. Non è possibile confrontare un `Int` con una `String` tramite questo protocollo.

Conformità a Equatable

```swift struct Point: Equatable { var x: Double var y: Double // Auto-synthesised: // static func == (lhs: Point, rhs: Point) -> Bool // { lhs.x == rhs.x && lhs.y == rhs.y } } print(Point(x:1,y:2) == Point(x:1,y:2)) // true ```

Comparable con Self

```swift struct Version: Comparable { let major, minor, patch: Int static func < (lhs: Version, rhs: Version) -> Bool { (lhs.major, lhs.minor, lhs.patch) < (rhs.major, rhs.minor, rhs.patch) } } let v1 = Version(major:1,minor:2,patch:0) let v2 = Version(major:2,minor:0,patch:0) print(v1 < v2) // true ```

Self come tipo restituito

```swift protocol Clonable { func clone() -> Self } class Animal: Clonable { var name: String = "" required init() {} func clone() -> Self { type(of: self).init() } } ``` `Self` nel tipo restituito indica che le sottoclassi restituiscono il proprio tipo, non `Animal`.

Protocollo con requisito Self (PAT)

```swift protocol Scalable { func scaled(by factor: Double) -> Self } struct Size: Scalable { var w, h: Double func scaled(by f: Double) -> Size { Size(w: w*f, h: h*f) } } ```

Hashable: Self + Equatable

```swift struct Color: Hashable { var r, g, b: UInt8 // Auto-synthesised: func hash(into:) and == } var palette: Set = [] palette.insert(Color(r:255,g:0,b:0)) ``` `Hashable` richiede `Equatable`: per le struct semplici, entrambe le conformità vengono sintetizzate automaticamente.

I protocolli con Self non possono essere usati direttamente come esistenziali

```swift // Before Swift 5.7: var shapes: [Equatable] = [] // ❌ Equatable has Self requirement // After Swift 5.7 with 'any': var boxes: [any Equatable] = [] // ⚠️ limited API ``` La parola chiave `any` abilita esplicitamente il boxing esistenziale.

Prerequisiti per la sintesi automatica

La sintesi automatica di `Equatable`/`Hashable`/`Comparable` richiede: • Tutte le proprietà memorizzate devono conformarsi allo stesso protocollo • I casi dell'enum, inclusi i valori associati, devono conformarsi ```swift struct Pair: Equatable { var a, b: T } // Equatable synthesised automatically ```

Ridefinizione personalizzata di Equatable

```swift struct Person: Equatable { var id: UUID var name: String // Only compare by id, ignore name: static func == (lhs: Person, rhs: Person) -> Bool { lhs.id == rhs.id } } ```

Verifica rapida

In un protocollo, a cosa si riferisce `Self`?

Riepilogo

Punti chiave: • `Self` = il tipo concreto che si conforma al protocollo • `Equatable`, `Comparable` e `Hashable` usano tutti `Self` • Swift sintetizza automaticamente queste conformità per struct ed enum semplici • `Self` nei tipi restituiti consente di creare API che preservano il tipo • I protocolli con requisiti Self richiedono `any` per i tipi esistenziali (Swift 5.7+) Successivo: principi della progettazione orientata ai protocolli.

Domande Frequenti

La lezione «Requisiti Self e progettazione Equatable» è gratuita?

Sì — il testo completo di «Requisiti Self e progettazione Equatable» è 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 «Requisiti Self e progettazione Equatable»?

I protocolli che usano Self e il modo in cui Equatable e Comparable ne sfruttano le capacità. 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 «Requisiti Self e progettazione Equatable»?

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

Composizione di protocolli con &
Conformità condizionale
Requisiti Self e progettazione Equatable
Principi della progettazione orientata ai protocolli

← Torna a Swift Academy