Tarifs d'un freelance

Les nombres

Swift propose deux grandes catégories de nombres : les entiers et les nombres à virgule flottante.

• Les entiers représentent des nombres sans partie fractionnaire, comme 0, 1, -1, 42 et -273.
• Les nombres à virgule flottante représentent des nombres dotés d'une partie fractionnaire, comme 0.0, 3.14 et -1.36969e-10.

Tu peux insérer des tirets bas dans les littéraux numériques pour en améliorer la lisibilité : 1_000_000 est identique à 1000000. Les littéraux à virgule flottante peuvent s'écrire en notation décimale ou exponentielle.

Dans la plupart des cas, on utilise Int pour les entiers et Double pour les nombres à virgule flottante :

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

Opérateurs arithmétiques

Swift fournit les opérateurs arithmétiques standards pour les calculs numériques :

Division

L'opérateur / effectue la division. Quand les deux opérandes sont des entiers, la division entière tronque toute partie fractionnaire :

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

Diviser un nombre à virgule flottante non nul par zéro donne inf ou -inf. Diviser 0.0 par 0.0 produit nan (Not a Number). En revanche, diviser un entier par zéro provoque une erreur à la compilation ou à l'exécution :

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

L'opérateur de reste

L'opérateur de reste (%) calcule le reste de la division de deux entiers :

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

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

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

Arrondir les nombres à virgule flottante

Tu peux arrondir un nombre à virgule flottante avec la méthode rounded(). Par défaut, rounded() arrondit à l'entier le plus proche. Tu peux aussi fournir une règle d'arrondi précise, comme .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

Inférence de type

Quand tu déclares une constante ou une variable numérique sans annotation de type, Swift en déduit le type :

• Les nombres entiers sont déduits comme des Int.
• Les nombres avec un point décimal sont déduits comme des Double.

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

Conversion de type

Pour effectuer des opérations entre des valeurs de types différents, convertis l'une des valeurs à l'aide d'initialiseurs de type comme 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)