Swift Academy · Aula

Coalescência de nil e operador ternário com opcionais

Use ?? para valores padrão e encadeie operadores de coalescência de nil.

Aula 2 de 412 etapas

Coalescência de nil e operador ternário com opcionais é 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.

Boas-vindas

O operador de coalescência de nil `??` fornece um valor padrão quando um opcional é nil. Combinado com o operador ternário, ele permite um tratamento conciso e expressivo de opcionais.

O operador ??

```swift let name: String? = nil let display = name ?? "Guest" print(display) // "Guest" let known: String? = "Alice" print(known ?? "Guest") // "Alice" ``` Se o opcional não for nil, seu valor desembrulhado será usado. Caso contrário, será usado o valor padrão.

Avaliação em curto-circuito

O lado direito de `??` só é avaliado quando o lado esquerdo é nil: ```swift func expensiveDefault() -> String { print("Computing...") return "Default" } let val: String? = "Existing" let result = val ?? expensiveDefault() // expensiveDefault not called ```

Encadeando ??

Encadeie vários operadores `??` para tentar várias alternativas: ```swift let primary: String? = nil let secondary: String? = nil let fallback = "Anonymous" let user = primary ?? secondary ?? fallback print(user) // "Anonymous" ``` A avaliação para no primeiro valor não nulo.

?? com propriedades computadas

```swift struct Config { var theme: String? var displayTheme: String { theme ?? "light" } } var c = Config() print(c.displayTheme) // "light" c.theme = "dark" print(c.displayTheme) // "dark" ``` Um padrão simples para valores padrão em propriedades computadas.

Operador ternário com opcionais

O ternário `condition ? a : b` pode ser usado com verificações de opcionais: ```swift let score: Int? = 85 let label = score != nil ? "\(score!)" : "No score" ``` Mas `??` geralmente é mais limpo: ```swift let label = score.map { "\($0)" } ?? "No score" ```

Optional.map para transformação

Transforme o valor encapsulado de um opcional sem desembrulhá-lo: ```swift let maybeInt: Int? = 42 let maybeStr = maybeInt.map { "Value: \($0)" } // Optional("Value: 42") let nilInt: Int? = nil let nilStr = nilInt.map { "Value: \($0)" } // nil ```

flatMap para encadeamento de opcionais

Use `flatMap` quando a própria transformação retornar um opcional: ```swift let str: String? = "123" let num = str.flatMap { Int($0) } // Optional(123) let bad: String? = "abc" let nil2 = bad.flatMap { Int($0) } // nil ```

Operador de atribuição ??= (não integrado)

O Swift não tem `??=` integrado, mas é possível simulá-lo: ```swift var cache: [String: Int] = [:] // Assign only if nil: if cache["key"] == nil { cache["key"] = expensiveCompute() } // Or with a helper: func ??= (lhs: inout T?, rhs: @autoclosure () -> T) { if lhs == nil { lhs = rhs() } } ```

Diretrizes de legibilidade

Escolha a ferramenta certa: • `??` — valores padrão simples • `if let` — quando precisar do valor desembrulhado em várias instruções • `guard let` — pré-condição e saída antecipada • `.map` / `.flatMap` — transformação sem desembrulhamento Evite o desembrulhamento forçado com `!`, a menos que o caso nil realmente não possa ocorrer.

Verificação rápida

O que `optional ?? default` retorna quando `optional` é `nil`?

Responda na aula interativa

Recapitulação

Principais conclusões: • `a ?? b` — retorna o valor de `a` se ele não for nil; caso contrário, retorna `b` • Usa curto-circuito: `b` só é avaliado quando `a` é nil • Encadeie: `a ?? b ?? c` • `.map` transforma o valor encapsulado; `.flatMap` lida com transformações que retornam um opcional • Prefira `??` a ternário com desembrulhamento forçado A seguir: encadeamento de opcionais com `?.`

Grátis para começar

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

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Coalescência de nil e operador ternário com opcionais” é grátis?

Sim — o texto completo de “Coalescência de nil e operador ternário com opcionais” é 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 “Coalescência de nil e operador ternário com opcionais”?

Use ?? para valores padrão e encadeie operadores de coalescência de nil. 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 “Coalescência de nil e operador ternário com opcionais”?

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

Vinculação com if let e guard let
Coalescência de nil e operador ternário com opcionais
Encadeamento opcional com ?.
Opcionais desembrulhados implicitamente e quando evitá-los

← Voltar para Swift Academy