Bienvenida
Swift ofrece un amplio conjunto de tipos numéricos integrados, un tipo booleano y un tipo Character para representar escalares Unicode individuales. Exploremos cada uno.
Tipos enteros
Swift proporciona enteros con signo y sin signo con distintos anchos de bits:
```swift
let a: Int = -42 // platform width (64-bit)
let b: Int8 = 127
let c: UInt = 255
let d: UInt8 = 200
```
Utilice `Int` para enteros de propósito general y tipos con un tamaño específico cuando el diseño de la memoria sea importante.
Int.min e Int.max
Cada tipo entero expone sus límites:
```swift
print(Int.min) // -9223372036854775808 on 64-bit
print(Int.max) // 9223372036854775807
print(UInt8.max) // 255
```
Desbordar estos límites produce un error en tiempo de ejecución (utilice los operadores de desbordamiento &+, &- para provocar un desbordamiento intencionado).
Punto flotante: Double y Float
```swift
let pi: Double = 3.14159265358979 // 64-bit, ~15 decimal digits
let e: Float = 2.71828 // 32-bit, ~6 decimal digits
```
Prefiera `Double` para la mayoría de los casos. Use `Float` solo cuando el tamaño de la memoria sea crítico (por ejemplo, en arrays grandes de valores).
Operadores aritméticos
Swift admite los operadores aritméticos estándar:
```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
```
Recuerde: dividir dos `Int` trunca el resultado hacia cero.
Tipo booleano: true y false
```swift
var isLoggedIn: Bool = false
isLoggedIn = true
if isLoggedIn {
print("Welcome back!")
}
```
Los valores booleanos de Swift son estrictos: no puede usar enteros como valores verdaderos o falsos, como en C.
Operadores booleanos
Estos son los tres operadores booleanos principales:
```swift
let a = true && false // AND → false
let b = true || false // OR → true
let c = !true // NOT → false
```
Evaluación en cortocircuito: en `&&`, el lado derecho solo se evalúa si el izquierdo es `true`.
Tipo Character
Un `Character` contiene un único clúster de grafemas extendido (un carácter legible para las personas):
```swift
let letter: Character = "A"
let emoji: Character = "🚀"
let accented: Character = "é"
```
Los literales de tipo `Character` usan comillas dobles, igual que `String`.
Character frente a String
Un `String` es una secuencia de valores `Character`:
```swift
let str = "Hello"
for ch in str {
print(ch) // H, e, l, l, o
}
```
Puede construir un `String` a partir de `Character` con `String(character)` o agregando caracteres a un `String` declarado con `var`.
Operadores de desbordamiento numérico
Cuando necesite un desbordamiento intencionado (por ejemplo, para manipular bits de hardware), use los operadores de desbordamiento:
```swift
var x: UInt8 = 255
x = x &+ 1 // wraps to 0 instead of crashing
```
Los operadores `&+`, `&-` y `&*` nunca producen un error por desbordamiento.
Comprobación rápida
¿Qué operador booleano de Swift devuelve `true` únicamente cuando **ambos** operandos son `true`?
Resumen
Ideas clave:
• Enteros: `Int` para uso general y tipos con tamaño definido (`Int8`, `UInt8`…) cuando sea necesario
• Números de coma flotante: se prefiere `Double` (64 bits); use `Float` (32 bits) para arrays en los que el espacio sea importante
• `Bool` es estricto: solo admite `true`/`false`, sin conversión implícita de enteros
• `Character` contiene un clúster de grafemas Unicode
• Use `&+`, `&-` y `&*` para provocar un desbordamiento intencionado
Siguiente: cadenas e interpolación.
Preguntas frecuentes
¿La lección «Números, booleanos y caracteres» es gratis?
Sí — el texto completo de «Números, booleanos y caracteres» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Swift Academy, actualiza a CoddyKit PRO. El curso de Swift Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Números, booleanos y caracteres»?
Trabaje con los tipos Int, Double, Float, Bool y Character. Practicas Swift Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Swift Academy?
No se requiere experiencia previa. Swift Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.
¿Cuánto tiempo toma la lección «Números, booleanos y caracteres»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Swift Academy?
Sí. Cada lección de Swift Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.