Nombres, booléens et caractères

Swift possède un ensemble riche de types numériques intégrés, un type booléen et un type caractère pour représenter des scalaires Unicode individuels. Explorons chacun d’eux.

Swift fournit des entiers signés et non signés avec différentes tailles en bits : ```swift let a: Int = -42 // platform width (64-bit) let b: Int8 = 127 let c: UInt = 255 let d: UInt8 = 200 ``` Utilisez `Int` pour les entiers à usage général ; utilisez les types de taille fixe lorsque la disposition mémoire est importante.

Chaque type entier expose ses limites : ```swift print(Int.min) // -9223372036854775808 on 64-bit print(Int.max) // 9223372036854775807 print(UInt8.max) // 255 ``` Dépasser ces limites provoque une erreur lors de l’exécution (utilisez les opérateurs de dépassement &+ et &- pour provoquer volontairement un dépassement).

```swift let pi: Double = 3.14159265358979 // 64-bit, ~15 decimal digits let e: Float = 2.71828 // 32-bit, ~6 decimal digits ``` Privilégiez `Double` pour la plupart des opérations. Utilisez `Float` uniquement lorsque la taille mémoire est essentielle (par exemple, pour de grands tableaux de valeurs).

Swift prend en charge les opérateurs arithmétiques standard : ```swift let sum = 10 + 3 // 13 let diff = 10 - 3 // 7 let prod = 10 * 3 // 30 let quot = 10 / 3 // 3 (integer division) let rem = 10 % 3 // 1 ``` N'oubliez pas : la division de deux `Int` tronque le résultat vers zéro.

```swift var isLoggedIn: Bool = false isLoggedIn = true if isLoggedIn { print("Welcome back!") } ``` Les booléens de Swift sont stricts : vous ne pouvez pas utiliser des entiers comme valeurs de vérité, contrairement à C.

Les trois opérateurs booléens fondamentaux : ```swift let a = true && false // AND → false let b = true || false // OR → true let c = !true // NOT → false ``` Évaluation en court-circuit : avec `&&`, le côté droit n'est évalué que si le côté gauche vaut `true`.

Un `Character` contient un cluster de graphèmes étendu (un caractère lisible par l'utilisateur) : ```swift let letter: Character = "A" let emoji: Character = "🚀" let accented: Character = "é" ``` Les littéraux de type `Character` utilisent des guillemets doubles, comme `String`.

Une `String` est une séquence de valeurs `Character` : ```swift let str = "Hello" for ch in str { print(ch) // H, e, l, l, o } ``` Vous pouvez construire une chaîne à partir de caractères avec `String(character)` ou en ajoutant des caractères à une chaîne déclarée avec `var`.

Lorsque vous avez besoin d'un dépassement intentionnel (par exemple, pour manipuler des bits au niveau matériel), utilisez les opérateurs de dépassement : ```swift var x: UInt8 = 255 x = x &+ 1 // wraps to 0 instead of crashing ``` Les opérateurs `&+`, `&-` et `&*` ne déclenchent jamais d'erreur d'exécution en cas de dépassement.

Points essentiels : • Entiers : `Int` pour un usage général, types de taille définie (`Int8`, `UInt8`…) lorsque nécessaire • Nombres à virgule flottante : `Double` (64 bits) est privilégié ; `Float` (32 bits) convient aux tableaux lorsque l'espace mémoire est limité • `Bool` est strict : uniquement `true` ou `false`, sans conversion automatique des entiers • `Character` contient un cluster de graphèmes Unicode • Utilisez `&+`, `&-` et `&*` pour un dépassement intentionnel Suite : chaînes et interpolation.