Acerca de Números
Números
Swift ofrece dos categorías principales de números: los números enteros y los números de coma flotante.
- Los números enteros representan números sin parte fraccionaria, como
0, 1, -1, 42 y -273.
- Los números de coma flotante representan números con una parte fraccionaria, como
0.0, 3.14 y -1.36969e-10.
Puedes insertar guiones bajos en los literales numéricos para mejorar la legibilidad: 1_000_000 es idéntico a 1000000.
Los literales de coma flotante pueden escribirse en notación decimal o exponencial.
En la mayoría de los casos, usarás Int para los números enteros y Double para los números de coma flotante:
let speed: Int = 42 // Explicit Int
let pi: Double = 3.14 // Explicit Double
let giga: Double = 1_000_000_000 // Double with readability underscores
let plancksConstant: Double = 6.62607015e-34 // Double in scientific notation
Operadores aritméticos
Swift proporciona los operadores aritméticos estándar para los cálculos numéricos:
| Operador |
Descripción |
Ejemplo |
+ |
Suma |
4 + 6 da como resultado 10
|
- |
Resta |
15 - 10 da como resultado 5
|
* |
Multiplicación |
2 * 3 da como resultado 6
|
Swift es un lenguaje de tipado seguro y no permite mezclar tipos numéricos distintos en las operaciones aritméticas.
No puedes sumar ni multiplicar directamente un Int y un Double; primero debes convertir uno de los tipos para que coincida con el otro.
División
El operador / realiza la división.
Cuando ambos operandos son números enteros, la división entera descarta cualquier residuo fraccionario:
5.0 / 2.0 // 2.5 (Double division)
5 / 2 // 2 (integer division truncates the remainder)
Dividir un número de coma flotante distinto de cero entre cero da como resultado inf o -inf.
Dividir 0.0 entre 0.0 produce nan (Not a Number).
En cambio, dividir un número entero entre cero provoca un error en tiempo de compilación o en tiempo de ejecución:
print(5.0 / 0.0) // Prints inf
print(-5.0 / 0.0) // Prints -inf
print(0.0 / 0.0) // Prints nan
// The following line will not compile:
// print(5 / 0) // Error: Division by zero
Operador de residuo
El operador de residuo (%) calcula el residuo que queda tras dividir dos números enteros:
5 % 2 // 1
-5 % 2 // -1
// Dividing by zero produces an error:
// 5 % 0 // Error: Division by zero
En Swift, % es un auténtico operador de residuo en lugar de un operador de módulo.
El resultado siempre toma el signo del primer operando (el dividendo), independientemente del signo del segundo operando:
5 % -2 // 1
-5 % 2 // -1
Redondear números de coma flotante
Puedes redondear un número de coma flotante con el método rounded().
De forma predeterminada, rounded() redondea al número entero más cercano.
También puedes indicar una regla de redondeo concreta, como .up o .down:
let x = 3.14
let y = x.rounded() // 3.0
let w = x.rounded(.down) // 3.0
let z = x.rounded(.up) // 4.0
Inferencia de tipos
Cuando declaras una constante o variable numérica sin anotación de tipo, Swift infiere su tipo:
- Los números enteros toman
Int de forma predeterminada.
- Los números con punto decimal toman
Double de forma predeterminada.
let x = 42 // Inferred as Int
let y = 42.0 // Inferred as Double
let z: Double = 42 // Explicitly typed as Double
Conversión de tipos
Para realizar operaciones entre valores de tipos distintos, convierte uno de los valores con inicializadores de tipo como Double(_:) o Int(_:):
let integerCount = 42
let floatingCount = Double(integerCount)
print(floatingCount) // Prints 42.0
let pi = 3.14
let integerPi = Int(pi)
print(integerPi) // Prints 3 (fractional part is truncated)
1 ejercicio
Aprende Números