Swift Academy · Lektion

break, continue und markierte Anweisungen

Steuern Sie den Schleifenfluss mit break, continue und markierten Schleifen in Swift.

break, continue und markierte Anweisungen ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Swift Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Willkommen

`break` und `continue` ermöglichen eine präzise Steuerung der Schleifenausführung. Labels erweitern diese Möglichkeiten auf verschachtelte Schleifen. Lernen Sie, wann welche Variante geeignet ist.

`break` – Schleife vorzeitig beenden

`break` beendet die aktuelle Schleife sofort: ```swift for i in 1...10 { if i == 5 { break } print(i) } // 1, 2, 3, 4 ``` Die Ausführung wird mit der ersten Anweisung nach der Schleife fortgesetzt.

`continue` – Aktuelle Iteration überspringen

`continue` überspringt den Rest der aktuellen Iteration und fährt mit der nächsten fort: ```swift for i in 1...10 { if i % 2 == 0 { continue } print(i) } // 1, 3, 5, 7, 9 ``` Das ist nützlich, um ungültige oder nicht benötigte Elemente zu überspringen.

`break` in while-Schleifen

`break` funktioniert in `while`-Schleifen genauso: ```swift var n = 0 while true { n += 1 if n >= 5 { break } } print(n) // 5 ``` Dies ist das idiomatische Muster `while true / break`, um eine Ereignisschleife zu beenden.

`break` in switch – Expliziter No-op

In Swift führt ein leerer `switch`-Fall zu einem Kompilierungsfehler. Verwenden Sie `break`, um ausdrücklich nichts zu tun: ```swift switch value { case .ignored: break // intentionally no action default: process(value) } ```

Schleifen mit Labels

Kennzeichnen Sie eine Schleife mit einem Bezeichner, auf den ein Doppelpunkt folgt: ```swift outerLoop: for row in 0..<3 { for col in 0..<3 { if row == 1 && col == 1 { break outerLoop } print("(\(row),\(col))") } } ``` `break outerLoop` beendet die *äußere* Schleife vollständig.

`continue` mit Labels

Labels funktionieren auch mit `continue`: Dadurch wird zur nächsten Iteration der äußeren Schleife gesprungen: ```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 und break kombinieren

Verwenden Sie nach Möglichkeit eine `where`-Klausel, um ein explizites `break` zu vermeiden: ```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) } ``` Bevorzugen Sie gut lesbare funktionale Alternativen gegenüber einem imperativen `break`.

Frühe Rückgabe statt `break`

Innerhalb einer Funktion beendet `return` sowohl die Schleife als auch die Funktion: ```swift func findFirst(_ target: Int, in array: [Int]) -> Int? { for element in array { if element == target { return element } } return nil } ``` Das ist oft übersichtlicher, als `break` zu verwenden und eine Ergebnisvariable zu verwalten.

`break` mit first(where:) vermeiden

Viele manuelle `break`-Muster lassen sich durch Methoden von Collections ersetzen: ```swift // break version: var found: Int? for n in numbers { if n > 10 { found = n; break } } // idiomatic: let found = numbers.first { $0 > 10 } ``` Die funktionale Variante ist kürzer und bringt die Absicht direkt zum Ausdruck.

Schnelltest

Welche Anweisung überspringt die **aktuelle** Iteration und fährt mit der nächsten fort?

Zusammenfassung

Die wichtigsten Punkte: • `break` – Schleife sofort beenden • `continue` – zur nächsten Iteration springen • Schleifen mit Labels (`label:`) ermöglichen es, `break`/`continue` auf eine äußere Schleife anzuwenden • Leere `switch`-Fälle erfordern ein explizites `break` • Bevorzugen Sie nach Möglichkeit funktionale Alternativen (`first(where:)`, `prefix`) gegenüber einem manuellen `break` Als Nächstes: Argumentbezeichnungen und Parameternamen in Funktionen.

Häufig gestellte Fragen

Ist die Lektion „break, continue und markierte Anweisungen“ kostenlos?

Ja — der vollständige Text von „break, continue und markierte Anweisungen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Swift Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „break, continue und markierte Anweisungen“?

Steuern Sie den Schleifenfluss mit break, continue und markierten Schleifen in Swift. Du übst Swift Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Swift Academy zu starten?

Keine Vorkenntnisse erforderlich. Swift Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „break, continue und markierte Anweisungen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Swift Academy-Lektion Code schreiben und ausführen?

Ja. Jede Swift Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

for-in-Schleifen mit Bereichen
while- und repeat-while-Schleifen
Sammlungen mit for-in durchlaufen
break, continue und markierte Anweisungen

← Zurück zu Swift Academy