Boas-vindas
O Swift oferece um conjunto abrangente de tipos numéricos integrados, um tipo booleano e um tipo Character para representar escalares Unicode individuais. Vamos explorar cada um deles.
Tipos inteiros
O Swift fornece inteiros com e sem sinal em várias larguras de bits:
```swift
let a: Int = -42 // platform width (64-bit)
let b: Int8 = 127
let c: UInt = 255
let d: UInt8 = 200
```
Use `Int` para inteiros de uso geral; use tipos com tamanho definido quando o layout da memória for importante.
Int.min e Int.max
Todo tipo inteiro expõe seus limites:
```swift
print(Int.min) // -9223372036854775808 on 64-bit
print(Int.max) // 9223372036854775807
print(UInt8.max) // 255
```
Ultrapassar esses limites causa um erro durante a execução (use os operadores de estouro &+, &- para provocar um estouro intencionalmente).
Ponto flutuante: Double e Float
```swift
let pi: Double = 3.14159265358979 // 64-bit, ~15 decimal digits
let e: Float = 2.71828 // 32-bit, ~6 decimal digits
```
Prefira `Double` na maioria dos casos. Use `Float` somente quando o tamanho da memória for essencial, por exemplo, em vetores grandes de valores.
Operadores aritméticos
O Swift oferece os operadores aritméticos padrão:
```swift
let sum = 10 + 3 // 13
let diff = 10 - 3 // 7
let prod = 10 * 3 // 30
let quot = 10 / 3 // 3 (integer division)
let rem = 10 % 3 // 1
```
Lembre-se: dividir dois Ints trunca o resultado em direção a zero.
Tipo booleano: true e false
```swift
var isLoggedIn: Bool = false
isLoggedIn = true
if isLoggedIn {
print("Welcome back!")
}
```
Os valores booleanos do Swift são estritos: não é possível usar inteiros como valores verdadeiros ou falsos, como em C.
Operadores booleanos
Os três operadores booleanos básicos:
```swift
let a = true && false // AND → false
let b = true || false // OR → true
let c = !true // NOT → false
```
Avaliação por curto-circuito: em `&&`, o lado direito só é avaliado se o lado esquerdo for `true`.
Tipo Character
Um `Character` armazena um único agrupamento de grafemas estendidos, ou seja, um caractere legível por humanos:
```swift
let letter: Character = "A"
let emoji: Character = "🚀"
let accented: Character = "é"
```
Literais do tipo Character usam aspas duplas, assim como String.
Caracteres versus textos
Uma `String` é uma sequência de valores `Character`:
```swift
let str = "Hello"
for ch in str {
print(ch) // H, e, l, l, o
}
```
Você pode criar um texto a partir de Characters com `String(character)` ou adicionando caracteres a uma String variável.
Operadores de estouro numérico
Quando precisar de um estouro intencional, por exemplo, para manipular bits de hardware, use operadores de estouro:
```swift
var x: UInt8 = 255
x = x &+ 1 // wraps to 0 instead of crashing
```
Os operadores `&+`, `&-` e `&*` nunca geram uma exceção por estouro.
Verificação rápida
Qual operador booleano do Swift retorna `true` somente quando **ambos** os operandos são `true`?
Recapitulação
Principais pontos:
• Inteiros: `Int` para uso geral e tipos com tamanho definido (`Int8`, `UInt8`…) quando necessário
• Números de ponto flutuante: `Double` (64 bits) é preferível; `Float` (32 bits) para vetores em que o espaço é importante
• `Bool` é estrito: aceita somente `true`/`false`, sem conversão automática de inteiros
• `Character` armazena um agrupamento de grafemas Unicode
• Use `&+`, `&-` e `&*` para obter estouro intencional
Próximo: textos e interpolação.
Perguntas Frequentes
A aula “Números, booleanos e caracteres” é grátis?
Sim — o texto completo de “Números, booleanos e caracteres” é 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 “Números, booleanos e caracteres”?
Trabalhe com os tipos Int, Double, Float, Bool e Character. 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 “Números, booleanos e caracteres”?
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.