Swift Academy · Aula

Inferência de tipos e tipos explícitos

Veja como o Swift infere tipos e quando declará-los explicitamente.

Inferência de tipos e tipos explícitos é 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 Swift é uma linguagem *tipada estaticamente* — todo valor tem um tipo conhecido durante a compilação. Porém, raramente você precisa escrever o tipo, pois o Swift o infere para você.

O que é inferência de tipos?

O Swift analisa o valor do lado direito e deduz o tipo automaticamente: ```swift let message = "Hello" // inferred as String let count = 42 // inferred as Int let price = 9.99 // inferred as Double ``` Nenhuma anotação de tipo é necessária — o compilador descobre o tipo por conta própria.

Anotações de tipo explícitas

Você sempre pode declarar o tipo explicitamente usando dois-pontos: ```swift let message: String = "Hello" let count: Int = 42 let price: Double = 9.99 ``` Isso é útil quando o tipo inferido não for o que você deseja.

Quando a inferência escolhe o tipo errado

Os literais de ponto flutuante assumem `Double` por padrão. Se precisar de `Float`, faça uma anotação explícita: ```swift let inferred = 3.14 // Double let explicit: Float = 3.14 // Float ``` Da mesma forma, os literais inteiros assumem `Int` por padrão — faça uma anotação para usar `Int32`, `UInt8` etc.

Segurança de tipos na prática

Depois que um tipo é definido, ele não pode mudar: ```swift var score = 0 // Int score = "ten" // ❌ cannot assign String to Int ``` A segurança de tipos detecta esse tipo de erro durante a compilação, muito antes da execução.

A função type(of:)

Use `type(of:)` para inspecionar o tipo durante a execução: ```swift let value = 42 print(type(of: value)) // Int let name = "Alice" print(type(of: name)) // String ``` Isso é útil para depurar resultados inesperados da inferência de tipos.

Pseudônimos de tipos

`typealias` dá um novo nome a um tipo existente para melhorar a legibilidade: ```swift typealias Celsius = Double typealias UserID = Int var temperature: Celsius = 36.6 var userId: UserID = 1001 ``` Os pseudônimos de tipos são apenas cosméticos — o tipo subjacente não muda.

Anotações sem inicialização

Quando você declara uma variável sem um valor inicial, *deve* anotar o tipo: ```swift var name: String // ✓ annotation required name = "Bob" var total: Int total = 0 ``` O Swift não tem como inferir um tipo quando não há um valor presente.

Literais numéricos e legibilidade

O Swift permite sublinhados em literais numéricos para melhorar a legibilidade: ```swift let million = 1_000_000 let hex = 0xFF_EC_D3 let binary = 0b1111_0000 ``` O compilador ignora os sublinhados — eles são apenas cosméticos.

Conversão de tipos — nenhuma conversão implícita

O Swift nunca converte tipos implicitamente. Você deve fazer isso explicitamente: ```swift let intVal: Int = 5 let dblVal: Double = Double(intVal) // explicit conversion let sum = Double(intVal) + 2.5 ``` Isso evita erros sutis causados por promoções numéricas não intencionais.

Verificação rápida

Que tipo o Swift infere para `let x = 3.14`?

Recapitulação

Principais conclusões: • O Swift infere os tipos a partir dos valores iniciais — normalmente não é necessária uma anotação • As anotações explícitas (`: Type`) substituem a inferência • Os valores de ponto flutuante assumem `Double` por padrão, e os inteiros assumem `Int` • Não há conversões implícitas — use `Int()`, `Double()` etc. • `type(of:)` revela o tipo durante a execução A seguir: os tipos fundamentais — números, Bool e Character.

Perguntas Frequentes

A aula “Inferência de tipos e tipos explícitos” é grátis?

Sim — o texto completo de “Inferência de tipos e tipos explícitos” é 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 “Inferência de tipos e tipos explícitos”?

Veja como o Swift infere tipos e quando declará-los explicitamente. 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 “Inferência de tipos e tipos explícitos”?

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