Swift Academy · Lekcja

break, continue i instrukcje z etykietami

Sterować przebiegiem pętli za pomocą break, continue i pętli z etykietami w Swift

break, continue i instrukcje z etykietami to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Swift Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Swift Academy zawiera 4 lekcji w sumie.

Wprowadzenie

`break` i `continue` zapewniają szczegółową kontrolę nad wykonywaniem pętli. Instrukcje etykietowane rozszerzają te możliwości na zagnieżdżone pętle. Należy poznać sytuacje, w których warto użyć każdej z nich.

break — wcześniejsze zakończenie pętli

`break` natychmiast kończy bieżącą pętlę: ```swift for i in 1...10 { if i == 5 { break } print(i) } // 1, 2, 3, 4 ``` Wykonywanie jest kontynuowane od pierwszej instrukcji znajdującej się za pętlą.

continue — pominięcie bieżącej iteracji

`continue` pomija pozostałą część bieżącej iteracji i przechodzi do następnej: ```swift for i in 1...10 { if i % 2 == 0 { continue } print(i) } // 1, 3, 5, 7, 9 ``` Jest przydatne do pomijania nieprawidłowych lub niepotrzebnych elementów.

break w pętlach while

`break` działa tak samo w pętlach `while`: ```swift var n = 0 while true { n += 1 if n >= 5 { break } } print(n) // 5 ``` Jest to typowy dla języka Swift wzorzec kończenia pętli zdarzeń `while true / break`.

break w switch — jawna operacja pusta

W języku Swift pusta gałąź `switch` powoduje błąd kompilacji. Należy użyć `break`, aby jawnie nie wykonywać żadnej operacji: ```swift switch value { case .ignored: break // intentionally no action default: process(value) } ```

Pętle etykietowane

Pętlę należy oznaczyć identyfikatorem zakończonym dwukropkiem: ```swift outerLoop: for row in 0..<3 { for col in 0..<3 { if row == 1 && col == 1 { break outerLoop } print("(\(row),\(col))") } } ``` `break outerLoop` całkowicie kończy *zewnętrzną* pętlę.

continue z etykietami

Etykiet można również używać z `continue`, aby przejść do następnej iteracji zewnętrznej pętli: ```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 ```

Łączenie where i break

Jeśli to możliwe, należy używać klauzuli `where`, aby uniknąć jawnego `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) } ``` Jeśli tylko zachowana jest czytelność, należy preferować alternatywy funkcyjne zamiast imperatywnego `break`.

Wczesny return a break

Wewnątrz funkcji `return` kończy zarówno pętlę, jak i działanie funkcji: ```swift func findFirst(_ target: Int, in array: [Int]) -> Int? { for element in array { if element == target { return element } } return nil } ``` Często jest to czytelniejsze niż użycie `break` i śledzenie wyniku w osobnej zmiennej.

Unikanie break za pomocą first(where:)

Wiele ręcznie tworzonych wzorców z `break` można zastąpić metodami kolekcji: ```swift // break version: var found: Int? for n in numbers { if n > 10 { found = n; break } } // idiomatic: let found = numbers.first { $0 > 10 } ``` Wersja funkcyjna jest krótsza i bezpośrednio wyraża zamiar programu.

Szybkie sprawdzenie

Która instrukcja pomija **bieżącą** iterację i przechodzi do następnej?

Podsumowanie

Najważniejsze informacje: • `break` — natychmiast kończy pętlę • `continue` — pomija bieżącą iterację i przechodzi do następnej • Pętle etykietowane (`label:`) pozwalają kierować `break` i `continue` do zewnętrznej pętli • Puste gałęzie switch wymagają jawnego `break` • Jeśli to możliwe, należy preferować alternatywy funkcyjne (`first(where:)`, `prefix`) zamiast ręcznego `break` Dalej: etykiety argumentów i nazwy parametrów w funkcjach.

Często zadawane pytania

Czy lekcja „break, continue i instrukcje z etykietami” jest bezpłatna?

Tak — pełny tekst „break, continue i instrukcje z etykietami” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Swift Academy, przejdź na CoddyKit PRO. Kurs Swift Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „break, continue i instrukcje z etykietami”?

Sterować przebiegiem pętli za pomocą break, continue i pętli z etykietami w Swift Ćwiczysz Swift Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Swift Academy?

Nie wymagamy żadnego doświadczenia. Swift Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „break, continue i instrukcje z etykietami”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Swift Academy?

Tak. Każda lekcja Swift Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Pętle for-in z zakresami
Pętle while i repeat-while
Iterowanie po kolekcjach za pomocą for-in
break, continue i instrukcje z etykietami

← Powrót do Swift Academy