Swift Academy · Aula

break, continue e instruções rotuladas

Controle o fluxo dos laços com break, continue e laços rotulados em Swift.

break, continue e instruções rotuladas é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

Boas-vindas

`break` e `continue` oferecem um controle detalhado da execução dos laços. As instruções rotuladas ampliam esse controle para laços aninhados. Vamos aprender quando cada recurso é apropriado.

break — sair do laço antecipadamente

`break` encerra imediatamente o laço atual: ```swift for i in 1...10 { if i == 5 { break } print(i) } // 1, 2, 3, 4 ``` A execução continua com a primeira instrução após o laço.

continue — ignorar a iteração atual

`continue` ignora o restante da iteração atual e passa à próxima: ```swift for i in 1...10 { if i % 2 == 0 { continue } print(i) } // 1, 3, 5, 7, 9 ``` É útil para ignorar elementos inválidos ou desnecessários.

break em laços while

`break` funciona da mesma forma em laços `while`: ```swift var n = 0 while true { n += 1 if n >= 5 { break } } print(n) // 5 ``` Este é o padrão idiomático de saída de um laço de eventos `while true / break`.

break em switch — operação vazia explícita

No Swift, um caso vazio de `switch` causa um erro de compilação. Use `break` para não fazer nada explicitamente: ```swift switch value { case .ignored: break // intentionally no action default: process(value) } ```

Laços rotulados

Rotule um laço com um identificador seguido de dois-pontos: ```swift outerLoop: for row in 0..<3 { for col in 0..<3 { if row == 1 && col == 1 { break outerLoop } print("(\(row),\(col))") } } ``` `break outerLoop` sai completamente do laço *externo*.

continue com rótulos

Os rótulos também funcionam com `continue`, passando à próxima iteração externa: ```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 ```

Combinando where e break

Use uma cláusula `where` para evitar um `break` explícito quando possível: ```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) } ``` Prefira alternativas funcionais a uma interrupção imperativa quando isso for legível.

Retorno antecipado vs. break

Dentro de uma função, `return` sai tanto do laço quanto da função: ```swift func findFirst(_ target: Int, in array: [Int]) -> Int? { for element in array { if element == target { return element } } return nil } ``` Frequentemente é mais claro do que usar `break` e acompanhar uma variável que armazena o resultado.

Evitando break com first(where:)

Muitos padrões manuais de `break` podem ser substituídos por métodos de coleção: ```swift // break version: var found: Int? for n in numbers { if n > 10 { found = n; break } } // idiomatic: let found = numbers.first { $0 > 10 } ``` A versão funcional é mais curta e expressa diretamente a intenção.

Verificação rápida

Qual instrução ignora a iteração **atual** e passa à próxima?

Recapitulação

Principais pontos: • `break` — sai imediatamente do laço • `continue` — passa à próxima iteração • Laços rotulados (`label:`) permitem que `break`/`continue` tenham como alvo um laço externo • Casos vazios de switch exigem um `break` explícito • Prefira alternativas funcionais (`first(where:)`, `prefix`) a um break manual sempre que possível A seguir: rótulos de argumentos e nomes de parâmetros em funções.

Perguntas Frequentes

A aula “break, continue e instruções rotuladas” é grátis?

Sim — o texto completo de “break, continue e instruções rotuladas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “break, continue e instruções rotuladas”?

Controle o fluxo dos laços com break, continue e laços rotulados em Swift. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “break, continue e instruções rotuladas”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Swift Academy