guard let per l’uscita anticipata
Svolgi l’optional ed esci subito in caso di errore per ridurre l’annidamento.
guard let per l’uscita anticipata è 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.
L'idea di guard
guard verifica una condizione e, se non viene soddisfatta, esce dall'ambito corrente. È pensato per le uscite anticipate, che mantengono il percorso principale senza rientri.
func greet(_ name: String?) {
guard let name else {
print("No name")
return
}
print("Hello, \(name)")
}
greet("Ada")
greet(nil)Sintassi di guard let
Scriva guard let value = optional else { return }. A differenza di if let, il valore estratto rimane nell'ambito dopo il guard.
func double(_ text: String) {
guard let n = Int(text) else {
print("Not a number")
return
}
print(n * 2)
}
double("8")
double("x")Il valore rimane disponibile
Poiché guard esce in caso di errore, il compilatore sa che il valore esiste in seguito. Può usarlo normalmente nel resto della funzione.
func length(of text: String?) {
guard let text else { return }
let count = text.count
print(count)
}
length("hello")L'else deve terminare
Il blocco else di un guard deve lasciare lo scope corrente: return, break, continue oppure throw. Questa regola è verificata dal compilatore.
func process(_ value: Int?) {
guard let value else {
return
}
print("Processing \(value)")
}
process(99)Forma abbreviata di guard let
Come if let, anche guard supporta una forma abbreviata: guard let name else { ... } quando i nomi corrispondono.
func show(_ name: String?) {
guard let name else {
print("missing")
return
}
print(name)
}
show("Kai")Percorso principale lineare
Il grande vantaggio di guard è un percorso principale lineare e leggibile. Confronti le piramidi di if let annidati con una serie di guard.
func register(name: String?, age: Int?) {
guard let name else { return }
guard let age else { return }
print("\(name) is \(age)")
}
register(name: "Mia", age: 28)Verifica di condizioni semplici
Guard funziona con qualsiasi condizione Bool, non solo con gli optional. guard count > 0 else { return } interrompe l'esecuzione in anticipo.
func divide(_ a: Int, by b: Int) {
guard b != 0 else {
print("Cannot divide by zero")
return
}
print(a / b)
}
divide(10, by: 2)
divide(10, by: 0)Guard nei cicli
All'interno di un ciclo, un guard può usare continue per saltare un'iterazione quando mancano dati.
let inputs = ["1", "x", "3"]
for item in inputs {
guard let n = Int(item) else { continue }
print(n * 10)
}Più binding in un unico guard
Un singolo guard può estrarre il valore di diversi optional, separandoli con virgole. Tutti devono riuscire affinché l'esecuzione possa proseguire.
func combine(_ a: String?, _ b: String?) {
guard let a, let b else { return }
print(a + b)
}
combine("foo", "bar")Guard con verifiche simili a where
È possibile aggiungere condizioni booleane dopo un binding, separandole con una virgola, per specificare ulteriormente quando il guard ha esito positivo.
func validate(_ text: String?) {
guard let text, !text.isEmpty else {
print("invalid")
return
}
print("ok: \(text)")
}
validate("")
validate("hi")Quando scegliere guard
Utilizzi guard per le precondizioni all'inizio di una funzione e if let quando le serve il valore solo brevemente all'interno di un ramo.
func area(width: Int?, height: Int?) -> Int {
guard let width, let height else { return 0 }
return width * height
}
print(area(width: 3, height: 4))Controllo rapido
Metta alla prova guard let.
Riepilogo: guard let per uscire in anticipo
guard let value else { return } estrae il valore di un optional e mantiene il valore nello scope in seguito. Il suo blocco else deve terminare l'esecuzione, mantenendo così il percorso principale lineare e leggibile.
func f(_ x: Int?) {
guard let x else { return }
print(x)
}
f(5)
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 «guard let per l’uscita anticipata» è gratuita?
Sì — il testo completo di «guard let per l’uscita anticipata» è 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 «guard let per l’uscita anticipata»?
Svolgi l’optional ed esci subito in caso di errore per ridurre l’annidamento. 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 «guard let per l’uscita anticipata»?
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
- if let e binding abbreviato
- guard let per l’uscita anticipata
- Binding di più optional
- Pattern degli optional in switch e for