Swift Academy · Aula

Encadeamento opcional com ?.

Chame métodos e acesse propriedades de opcionais sem causar falhas.

Encadeamento opcional com ?. é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 3 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 encadeamento de opcionais permite chamar métodos, acessar propriedades e usar subscritos por meio de uma cadeia de opcionais — com segurança. Se qualquer elo da cadeia for nil, toda a expressão retornará nil sem causar uma falha.

O operador ?.

```swift struct Address { var city: String } struct Person { var address: Address? } let alice = Person(address: Address(city: "Istanbul")) let bob = Person(address: nil) print(alice.address?.city) // Optional("Istanbul") print(bob.address?.city) // nil ```

Encadeando vários níveis

As cadeias podem ter profundidade arbitrária: ```swift struct Company { var ceo: Person? } let company = Company(ceo: alice) let city = company.ceo?.address?.city print(city ?? "Unknown") // "Istanbul" ``` Se `ceo` ou `address` for nil, `city` se tornará nil.

Chamando métodos por encadeamento

Os métodos também podem ser chamados por meio do encadeamento de opcionais: ```swift var name: String? = "alice" let upper = name?.uppercased() // Optional("ALICE") name = nil let upper2 = name?.uppercased() // nil ``` O tipo de retorno torna-se opcional: `String` torna-se `String?`.

Subscritos por encadeamento

```swift var dict: [String: [Int]]? = ["scores": [10, 20, 30]] let first = dict?["scores"]?[0] // Optional(10) dict = nil let none = dict?["scores"]?[0] // nil ``` Os subscritos funcionam da mesma forma que as propriedades e os métodos em uma cadeia.

O encadeamento produz um opcional

Mesmo que o resultado final não seja opcional, o encadeamento o encapsula em um opcional: ```swift struct Cat { var lives: Int = 9 } var cat: Cat? = Cat() let lives = cat?.lives // Int? not Int ``` Desembrulhe com `??`, `if let` ou `guard let`, conforme necessário.

Definindo valores por meio do encadeamento

Pode definir propriedades por meio de encadeamentos de opcionais: ```swift var profile: UserProfile? = UserProfile() profile?.name = "Alice" ``` Se `profile` for nil, a atribuição será silenciosamente ignorada (sem causar uma falha).

Chamando métodos Void por meio do encadeamento

```swift var manager: SoundManager? manager?.play() // silently ignored if nil ``` A chamada retorna `Void?` — `()` se não for nil e `nil` se o opcional for nil. Pode verificar o resultado para saber se a chamada foi realizada.

Encadeamento de opcionais versus desempacotamento forçado

```swift // Forced unwrap — crashes if nil: let city = alice.address!.city // Optional chaining — safe: let city = alice.address?.city ``` Prefira sempre o encadeamento de opcionais. Use `!` somente quando tiver certeza de que nil não pode ocorrer.

Combinando com ?? para obter valores padrão

Encadeie `??` depois do encadeamento de opcionais para definir valores padrão de forma clara: ```swift let displayCity = user.profile?.address?.city ?? "Unknown City" let count = database?.records?.count ?? 0 ``` O encadeamento inteiro ou resulta em um valor ou recorre ao valor padrão.

Verificação rápida

Se qualquer elo de um encadeamento de opcionais for `nil`, o que a expressão inteira retornará?

Recapitulação

Pontos principais: • `?.` acessa propriedades, chama métodos e usa subscritos de opcionais com segurança • Se qualquer elo for nil, o encadeamento inteiro retornará nil • O tipo do resultado será sempre opcional (mesmo que o valor final normalmente não seja) • Combine `?.` com `??` para criar padrões claros de acesso seguro com valor padrão • Prefira `?.` a `!` para evitar falhas A seguir: opcionais desempacotados implicitamente.

Perguntas Frequentes

A aula “Encadeamento opcional com ?. ” é grátis?

Sim — o texto completo de “Encadeamento opcional com ?. ” é 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 “Encadeamento opcional com ?. ”?

Chame métodos e acesse propriedades de opcionais sem causar falhas. 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 3 de 4.

Quanto tempo leva a aula “Encadeamento opcional com ?. ”?

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