guard let para Saída Antecipada
Desembrulhe valores e saia antecipadamente em caso de falha para reduzir o aninhamento.
guard let para Saída Antecipada é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 2 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.
A Ideia de guard
guard verifica uma condição e, se ela falhar, sai do escopo atual. Ele foi criado para saídas antecipadas que mantêm o caminho principal sem recuo.
func greet(_ name: String?) {
guard let name else {
print("No name")
return
}
print("Hello, \(name)")
}
greet("Ada")
greet(nil)Sintaxe de guard let
Escreva guard let value = optional else { return }. Diferentemente de if let, o valor desembrulhado continua disponível no escopo depois do guard.
func double(_ text: String) {
guard let n = Int(text) else {
print("Not a number")
return
}
print(n * 2)
}
double("8")
double("x")O Valor Continua Disponível
Como guard encerra a execução quando há uma falha, o compilador sabe que o valor existe depois dele. Você pode usá-lo normalmente no restante da função.
func length(of text: String?) {
guard let text else { return }
let count = text.count
print(count)
}
length("hello")O bloco alternativo deve sair
O bloco else de uma guarda deve sair do escopo atual: return, break, continue ou throw. Isso é imposto pelo compilador.
func process(_ value: Int?) {
guard let value else {
return
}
print("Processing \(value)")
}
process(99)Forma abreviada de guarda com vinculação
Assim como if let, a guarda aceita uma forma abreviada: guard let name else { ... } quando os nomes coincidem.
func show(_ name: String?) {
guard let name else {
print("missing")
return
}
print(name)
}
show("Kai")Fluxo principal simples
A grande vantagem da guarda é um fluxo principal simples, legível e sem aninhamento. Compare pirâmides aninhadas de if let com uma série de guardas.
func register(name: String?, age: Int?) {
guard let name else { return }
guard let age else { return }
print("\(name) is \(age)")
}
register(name: "Mia", age: 28)Protegendo condições simples
A guarda funciona com qualquer condição booleana, não apenas com opcionais. guard count > 0 else { return } encerra a execução antecipadamente.
func divide(_ a: Int, by b: Int) {
guard b != 0 else {
print("Cannot divide by zero")
return
}
print(a / b)
}
divide(10, by: 2)
divide(10, by: 0)Guarda em laços
Dentro de um laço, uma guarda pode usar continue para ignorar uma iteração quando os dados estão ausentes.
let inputs = ["1", "x", "3"]
for item in inputs {
guard let n = Int(item) else { continue }
print(n * 10)
}Várias vinculações em uma guarda
Uma única guarda pode desembrulhar vários opcionais, separados por vírgulas. Todos devem ter sucesso para que a execução continue.
func combine(_ a: String?, _ b: String?) {
guard let a, let b else { return }
print(a + b)
}
combine("foo", "bar")Guarda com verificações condicionais
Você pode adicionar condições booleanas depois de uma vinculação, separando-as por vírgula, para restringir quando a guarda será aprovada.
func validate(_ text: String?) {
guard let text, !text.isEmpty else {
print("invalid")
return
}
print("ok: \(text)")
}
validate("")
validate("hi")Quando escolher a guarda
Use guard para pré-condições no início de uma função e if let quando precisar do valor apenas brevemente dentro de um ramo.
func area(width: Int?, height: Int?) -> Int {
guard let width, let height else { return 0 }
return width * height
}
print(area(width: 3, height: 4))Verificação rápida
Teste a guarda com vinculação.
Recapitulação: vinculação com guarda para saída antecipada
guard let value else { return } desembrulha um opcional e mantém o valor no escopo posteriormente. Seu bloco else deve sair da execução, mantendo o fluxo principal simples e legível.
func f(_ x: Int?) {
guard let x else { return }
print(x)
}
f(5)
Aprenda Swift com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 122
- Aulas
- 409
Perguntas Frequentes
A aula “guard let para Saída Antecipada” é grátis?
Sim — o texto completo de “guard let para Saída Antecipada” é 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 “guard let para Saída Antecipada”?
Desembrulhe valores e saia antecipadamente em caso de falha para reduzir o aninhamento. 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 2 de 4.
Quanto tempo leva a aula “guard let para Saída Antecipada”?
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
- if let e Vinculação Abreviada
- guard let para Saída Antecipada
- Vinculação de Vários Opcionais
- Padrão de Opcional em switch e for