Tarifas de freelancer

Números

O Swift disponibiliza duas categorias principais de números: os números inteiros e os números de vírgula flutuante.

• Os números inteiros representam números sem parte fracionária, como 0, 1, -1, 42 e -273.
• Os números de vírgula flutuante representam números com uma parte fracionária, como 0.0, 3.14 e -1.36969e-10.

Podes inserir sublinhados nos literais numéricos para os tornar mais legíveis: 1_000_000 é idêntico a 1000000. Os literais de vírgula flutuante podem ser escritos em notação decimal ou exponencial.

Na maioria dos casos, usas Int para os números inteiros e Double para os números de vírgula flutuante:

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

O Swift disponibiliza operadores aritméticos padrão para cálculos numéricos:

Divisão

O operador / efetua a divisão. Quando ambos os operandos são números inteiros, a divisão inteira trunca qualquer resto fracionário:

5.0 / 2.0 // 2.5 (Double division)
5 / 2     // 2 (integer division truncates the remainder)

Dividir um número de vírgula flutuante diferente de zero por zero dá inf ou -inf. Dividir 0.0 por 0.0 produz nan (não é um número). Em contrapartida, dividir um número inteiro por zero provoca um erro de compilação ou de execução:

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 resto

O operador de resto (%) calcula o resto que sobra depois de dividir dois números inteiros:

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

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

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

Arredondar números de vírgula flutuante

Podes arredondar um número de vírgula flutuante com o método rounded(). Por omissão, rounded() arredonda para o número inteiro mais próximo. Também podes indicar uma regra de arredondamento específica, como .up ou .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

Inferência de tipos

Quando declaras uma constante ou variável numérica sem anotação de tipo, o Swift infere o tipo:

• Os números inteiros são, por omissão, do tipo Int.
• Os números com parte decimal são, por omissão, do tipo Double.

let x = 42         // Inferred as Int
let y = 42.0       // Inferred as Double
let z: Double = 42 // Explicitly typed as Double

Conversão de tipos

Para efetuar operações entre valores de tipos diferentes, converte um dos valores com inicializadores de tipo como Double(_:) ou 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)