Tarifas de freelancer

Números

Swift ofrece dos categorías principales de números: los enteros y los 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 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 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 operadores aritméticos estándar para hacer cálculos numéricos:

División

El operador / realiza la división. Cuando ambos operandos son 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 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

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

Redondeo de números de punto flotante

Puedes redondear un número de punto flotante con el método rounded(). Por defecto, 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 una variable numérica sin una anotación de tipo, Swift infiere su tipo:

• Los números enteros toman Int por defecto.
• Los números con un punto decimal toman Double por defecto.

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 hacer operaciones entre valores de distintos tipos, convierte un valor 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)