Clausole where sulle funzioni
Aggiungi vincoli dettagliati alle funzioni generiche.
Clausole where sulle funzioni è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 2 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.
Oltre i vincoli semplici
Un vincolo come <T: Collection> descrive T stesso. Tuttavia, a volte è necessario vincolare i tipi associati di T, ad esempio il suo Element. A questo serve una clausola where.
func sumInts<C: Collection>(_ c: C) -> Int where C.Element == Int {
c.reduce(0, +)
}
print(sumInts([1, 2, 3]))Requisito di uguaglianza tra tipi
where C.Element == Int richiede che gli elementi della raccolta siano esattamente di tipo Int, consentendo operazioni specifiche sugli interi.
func describe<C: Collection>(_ c: C) -> String where C.Element == Int {
"Sum is " + String(c.reduce(0, +))
}
print(describe(Set([1, 2, 3])))Requisito di protocollo sull'elemento
È possibile richiedere che l'elemento sia conforme a un protocollo anziché appartenere a un unico tipo preciso, ottenendo maggiore flessibilità.
func joinAll<C: Collection>(_ c: C) -> String
where C.Element: CustomStringConvertible {
c.map { $0.description }.joined(separator: ", ")
}
print(joinAll([1, 2, 3]))La clausola where viene dopo la firma
La clausola where si trova tra il tipo restituito e il corpo della funzione. I vincoli all'interno di <> e quelli della clausola where operano insieme.
func maxElement<C: Collection>(_ c: C) -> C.Element?
where C.Element: Comparable {
c.max()
}
print(maxElement([4, 9, 2])!)Correlare due parametri di tipo
Una clausola where può collegare i tipi degli elementi di due diversi generici usando ==.
func combine<A: Collection, B: Collection>(_ a: A, _ b: B) -> [A.Element]
where A.Element == B.Element {
Array(a) + Array(b)
}
print(combine([1, 2], Set([3])))Più condizioni where
Elenchi diversi requisiti separati da virgole per esprimere vincoli composti.
func report<C: Collection>(_ c: C)
where C.Element: Comparable, C.Element: CustomStringConvertible {
if let m = c.max() { print("max:", m.description) }
}
report([5, 1, 9])Vincolare tipi associati annidati
È possibile raggiungere livelli più profondi, ad esempio richiedendo il tipo dell'elemento di un elemento, quando si lavora con raccolte annidate.
func flatten<C: Collection>(_ c: C) -> [Int]
where C.Element: Collection, C.Element.Element == Int {
c.flatMap { Array($0) }
}
print(flatten([[1, 2], [3]]))where con elementi Equatable
Richiedere elementi Equatable consente di cercare in una raccolta generica.
func indexOf<C: Collection>(_ x: C.Element, in c: C) -> C.Index?
where C.Element: Equatable {
c.firstIndex(of: x)
}
if let i = indexOf(2, in: [1, 2, 3]) { print("found") }Metodi generici con where
Anche i metodi all'interno dei tipi generici usano where, spesso per aggiungere comportamenti solo per determinati tipi di elemento.
struct Wrap<T> {
let items: [T]
func total() -> Int where T == Int { items.reduce(0, +) }
}
print(Wrap(items: [1, 2, 3]).total())Vantaggio in termini di leggibilità
I vincoli complessi risultano più chiari in una clausola where anziché essere concentrati tra parentesi angolari, soprattutto quando sono presenti diverse condizioni sui tipi associati.
func first<C: Collection>(_ c: C) -> String
where C.Element: CustomStringConvertible {
c.first.map { $0.description } ?? "empty"
}
print(first([10, 20]))where nella libreria standard
Metodi come joined() sulle sequenze di sequenze usano internamente clausole where per esprimere con precisione i propri requisiti.
let nested = [[1, 2], [3, 4]]
print(Array(nested.joined()))Verifica rapida
Verifichi la Sua comprensione delle clausole where nelle funzioni.
Riepilogo
Le clausole where consentono di vincolare i tipi associati di un generico: richiedere che un elemento sia di un tipo specifico (== Int), che sia conforme a un protocollo (: Comparable), correlare gli elementi di due parametri o raggiungere tipi associati annidati. Si trovano dopo la firma e mantengono leggibili i vincoli complessi.
Impara Swift con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 122
- Lezioni
- 409
Domande Frequenti
La lezione «Clausole where sulle funzioni» è gratuita?
Sì — il testo completo di «Clausole where sulle funzioni» è 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 «Clausole where sulle funzioni»?
Aggiungi vincoli dettagliati alle funzioni generiche. 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 2 di 4.
Quanto tempo richiede la lezione «Clausole where sulle funzioni»?
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
- Vincoli sui parametri di tipo
- Clausole where sulle funzioni
- Vincoli sui tipi associati
- Subscript ed estensioni generiche