Swift Academy · Les

break, continue en gelabelde statements

Regel de control flow van lussen met break, continue en gelabelde lussen in Swift.

Les 4 van 412 stappen

break, continue en gelabelde statements is een gratis Swift Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Swift Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Swift Academy bevat in totaal 4 lessen.

Welkom

`break` en `continue` geven je nauwkeurige controle over de uitvoering van lussen. Gelabelde instructies breiden die mogelijkheid uit naar geneste lussen. Laten we bekijken wanneer je welke gebruikt.

break — De lus vroegtijdig verlaten

`break` beëindigt de huidige lus onmiddellijk: ```swift for i in 1...10 { if i == 5 { break } print(i) } // 1, 2, 3, 4 ``` De uitvoering gaat verder met de eerste instructie na de lus.

continue — De huidige iteratie overslaan

`continue` slaat de rest van de huidige iteratie over en gaat naar de volgende: ```swift for i in 1...10 { if i % 2 == 0 { continue } print(i) } // 1, 3, 5, 7, 9 ``` Handig om ongeldige of onnodige elementen over te slaan.

break in while-lussen

`break` werkt op dezelfde manier in `while`-lussen: ```swift var n = 0 while true { n += 1 if n >= 5 { break } } print(n) // 5 ``` Dit is het idiomatische patroon `while true / break` om een gebeurtenislus te verlaten.

break in switch — Expliciet niets doen

In Swift is een lege `switch`-case een compileerfout. Gebruik `break` om expliciet niets te doen: ```swift switch value { case .ignored: break // intentionally no action default: process(value) } ```

Gelabelde lussen

Geef een lus een label met een identifier gevolgd door een dubbele punt: ```swift outerLoop: for row in 0..<3 { for col in 0..<3 { if row == 1 && col == 1 { break outerLoop } print("(\(row),\(col))") } } ``` `break outerLoop` verlaat de *buitenste* lus volledig.

continue met labels

Labels werken ook met `continue`, waarmee je naar de volgende iteratie van de buitenste lus gaat: ```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 ```

where en break combineren

Gebruik waar mogelijk een `where`-clausule in plaats van een expliciete `break`: ```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) } ``` Geef de voorkeur aan functionele alternatieven boven een imperatieve break als dat leesbaar blijft.

Vroegtijdige return versus break

Binnen een functie verlaat `return` zowel de lus als de functie: ```swift func findFirst(_ target: Int, in array: [Int]) -> Int? { for element in array { if element == target { return element } } return nil } ``` Vaak overzichtelijker dan `break` gebruiken en een resultaatvariabele bijhouden.

break vermijden met first(where:)

Veel handmatige breakpatronen kun je vervangen door methoden van collecties: ```swift // break version: var found: Int? for n in numbers { if n > 10 { found = n; break } } // idiomatic: let found = numbers.first { $0 > 10 } ``` De functionele versie is korter en maakt de bedoeling direct duidelijk.

Korte controle

Welke instructie slaat de **huidige** iteratie over en gaat naar de volgende?

Beantwoord dit in de interactieve les

Samenvatting

Belangrijkste punten: • `break` — de lus onmiddellijk verlaten • `continue` — naar de volgende iteratie gaan • Met gelabelde lussen (`label:`) kun je met `break`/`continue` een buitenste lus aanspreken • Lege switch-cases vereisen een expliciete `break` • Geef waar mogelijk de voorkeur aan functionele alternatieven (`first(where:)`, `prefix`) boven een handmatige break Hierna: argumentlabels en parameternamen in functies.

Gratis beginnen

Leer Swift met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 122
Lessen: 409

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “break, continue en gelabelde statements” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Swift Academy, waaronder “break, continue en gelabelde statements”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Swift Academy bevat in totaal 4 lessen.

Wat leer ik in “break, continue en gelabelde statements”?

Regel de control flow van lussen met break, continue en gelabelde lussen in Swift. Je oefent met Swift Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Swift Academy te beginnen?

Ervaring vooraf is niet nodig. Swift Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.

Hoe lang duurt de les “break, continue en gelabelde statements”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Swift Academy?

Ja. Elke les over Swift Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Swift Academy