Swift Academy · Lezione

break, continue e istruzioni con etichetta

Controlli il flusso dei cicli con break, continue e cicli con etichetta in Swift.

Lezione 4 di 412 passaggi

break, continue e istruzioni con etichetta è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 4 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

`break` e `continue` consentono di controllare con precisione l'esecuzione dei cicli. Le istruzioni con etichette estendono questa possibilità ai cicli annidati. Vediamo quando è opportuno usare ciascuno.

break — Uscire anticipatamente dal ciclo

`break` termina immediatamente il ciclo corrente: ```swift for i in 1...10 { if i == 5 { break } print(i) } // 1, 2, 3, 4 ``` L'esecuzione prosegue con la prima istruzione successiva al ciclo.

continue — Saltare l'iterazione corrente

`continue` salta il resto dell'iterazione corrente e passa a quella successiva: ```swift for i in 1...10 { if i % 2 == 0 { continue } print(i) } // 1, 3, 5, 7, 9 ``` È utile per saltare gli elementi non validi o non necessari.

break nei cicli while

`break` si comporta allo stesso modo nei cicli `while`: ```swift var n = 0 while true { n += 1 if n >= 5 { break } } print(n) // 5 ``` Questo è il pattern idiomatico per uscire da un event loop basato su `while true / break`.

break in switch — No-op esplicito

In Swift, un case `switch` vuoto provoca un errore di compilazione. Utilizzi `break` per non eseguire esplicitamente alcuna operazione: ```swift switch value { case .ignored: break // intentionally no action default: process(value) } ```

Cicli con etichette

Etichetti un ciclo con un identificatore seguito da due punti: ```swift outerLoop: for row in 0..<3 { for col in 0..<3 { if row == 1 && col == 1 { break outerLoop } print("(\(row),\(col))") } } ``` `break outerLoop` esce completamente dal ciclo *esterno*.

continue con le etichette

Le etichette funzionano anche con `continue`, che passa alla successiva iterazione del ciclo esterno: ```swift outerLoop: for row in 0..<3 { for col in 0..<3 { if col == 1 { continue outerLoop } print("(\(row),\(col))") } } // skips rest of inner loop when col reaches 1 ```

Combinare where e break

Utilizzi una clausola `where` per evitare un `break` esplicito quando possibile: ```swift // Less idiomatic: for n in 1...100 { if n > 10 { break } print(n) } // More idiomatic: for n in (1...100).prefix(10) { print(n) } ``` Preferisca le alternative funzionali al `break` imperativo quando risultano leggibili.

return anticipato vs break

All'interno di una funzione, `return` esce sia dal ciclo sia dalla funzione: ```swift func findFirst(_ target: Int, in array: [Int]) -> Int? { for element in array { if element == target { return element } } return nil } ``` Spesso è più pulito che usare `break` e tenere traccia di una variabile risultato.

Evitare break con first(where:)

Molti pattern manuali con `break` possono essere sostituiti dai metodi delle collezioni: ```swift // break version: var found: Int? for n in numbers { if n > 10 { found = n; break } } // idiomatic: let found = numbers.first { $0 > 10 } ``` La versione funzionale è più breve ed esprime direttamente l'intento.

Verifica rapida

Quale istruzione salta l'iterazione **corrente** e passa a quella successiva?

Rispondi nella lezione interattiva

Riepilogo

Punti chiave: • `break` — esce immediatamente dal ciclo • `continue` — passa all'iterazione successiva • I cicli con etichette (`label:`) consentono a `break`/`continue` di agire su un ciclo esterno • I case vuoti di `switch` richiedono un `break` esplicito • Quando possibile, preferisca le alternative funzionali (`first(where:)`, `prefix`) al `break` manuale Successivo: etichette degli argomenti e nomi dei parametri nelle funzioni.

Gratis per iniziare

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

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «break, continue e istruzioni con etichetta» è gratuita?

Sì — il testo completo di «break, continue e istruzioni con etichetta» è 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 «break, continue e istruzioni con etichetta»?

Controlli il flusso dei cicli con break, continue e cicli con etichetta in Swift. 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 4 di 4.

Quanto tempo richiede la lezione «break, continue e istruzioni con etichetta»?

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

Cicli for-in con intervalli
Cicli while e repeat-while
Iterazione delle collezioni con for-in
break, continue e istruzioni con etichetta

← Torna a Swift Academy