Tarifas de freelance

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 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 realizar cálculos numéricos:

División

El operador / realiza la división. Cuando ambos operandos son números enteros, la división entera trunca 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 (no es un número). En cambio, dividir un número entero entre cero provoca un error en tiempo de compilación o 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 números enteros:

5 % 2  // 1
-5 % 2 // -1

// Dividing by zero produces an error:
// 5 % 0 // Error: Division by zero

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 una variable numérica sin anotación de tipo, Swift infiere su tipo:

• Los números enteros usan Int de forma predeterminada.
• Los números con parte decimal usan 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 diferentes, 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)