Acerca de Números
Números
Swift ofrece dos categorías principales de números: enteros y números de punto flotante.
- Los enteros representan números sin parte fraccionaria, como
0, 1, -1, 42 y -273.
- Los números de punto flotante representan números con 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 punto flotante se pueden escribir en notación decimal o exponencial.
En la mayoría de los casos, usas Int para los enteros y Double para los números de punto 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 ofrece 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 de tipado seguro y no permite mezclar distintos tipos numéricos en las operaciones aritméticas.
No puedes sumar ni multiplicar directamente un Int y un Double; primero debes convertir un tipo para que coincida con el otro.
División
El operador / realiza la división.
Cuando ambos operandos son enteros, la división entera descarta el residuo fraccionario:
5.0 / 2.0 // 2.5 (Double division)
5 / 2 // 2 (integer division truncates the remainder)
Dividir un número de punto flotante distinto de cero entre cero da como resultado inf o -inf.
Dividir 0.0 entre 0.0 produce nan (no es un número).
En cambio, dividir un 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 después de dividir dos enteros:
5 % 2 // 1
-5 % 2 // -1
// Dividing by zero produces an error:
// 5 % 0 // Error: Division by zero
En Swift, % es un verdadero operador de residuo y no un operador de módulo.
El resultado siempre toma el signo del primer operando (el dividendo), sin importar el signo del segundo operando:
5 % -2 // 1
-5 % 2 // -1
Redondear números de punto flotante
Puedes redondear un número de punto flotante con el método rounded().
De forma predeterminada, rounded() redondea al entero más cercano.
También puedes indicar una regla de redondeo específica, 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 una anotación de tipo, Swift infiere su tipo:
- Los números enteros son
Int de forma predeterminada.
- Los números con punto decimal son
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 distintos tipos, convierte un valor usando los 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