Swift Language
Nombres
Recherche…
Types de nombres et littéraux
Les types numériques intégrés à Swift sont:
- Taille Word (dépendant de l' architecture) signé Int et non signé UInt .
- Entiers signés de taille fixe Int8 , Int16 , Int32 , Int64 et entiers non signés UInt8 , UInt16 , UInt32 , UInt64 .
- Float32 / Float , Float64 / Double et Float80 (x86 uniquement) de type à virgule flottante .
Littéraux
Le type d'un littéral numérique est déduit du contexte:
let x = 42 // x is Int by default
let y = 42.0 // y is Double by default
let z: UInt = 42 // z is UInt
let w: Float = -1 // w is Float
let q = 100 as Int8 // q is Int8
Underscores ( _ ) peut être utilisé pour séparer les chiffres des littéraux numériques. Les zéros en tête sont ignorés.
Les littéraux à virgule flottante peuvent être spécifiés en utilisant des parties significand et exposant ( «significand» e «exponent» pour la décimale; 0x «significand» p «exponent» pour hexadécimal).
Entier la syntaxe littérale
let decimal = 10 // ten
let decimal = -1000 // negative one thousand
let decimal = -1_000 // equivalent to -1000
let decimal = 42_42_42 // equivalent to 424242
let decimal = 0755 // equivalent to 755, NOT 493 as in some other languages
let decimal = 0123456789
let hexadecimal = 0x10 // equivalent to 16
let hexadecimal = 0x7FFFFFFF
let hexadecimal = 0xBadFace
let hexadecimal = 0x0123_4567_89ab_cdef
let octal = 0o10 // equivalent to 8
let octal = 0o755 // equivalent to 493
let octal = -0o0123_4567
let binary = -0b101010 // equivalent to -42
let binary = 0b111_101_101 // equivalent to 0o755
let binary = 0b1011_1010_1101 // equivalent to 0xB_A_D
Syntaxe littérale à virgule flottante
let decimal = 0.0
let decimal = -42.0123456789
let decimal = 1_000.234_567_89
let decimal = 4.567e5 // equivalent to 4.567×10⁵, or 456_700.0
let decimal = -2E-4 // equivalent to -2×10⁻⁴, or -0.0002
let decimal = 1e+0 // equivalent to 1×10⁰, or 1.0
let hexadecimal = 0x1p0 // equivalent to 1×2⁰, or 1.0
let hexadecimal = 0x1p-2 // equivalent to 1×2⁻², or 0.25
let hexadecimal = 0xFEEDp+3 // equivalent to 65261×2³, or 522088.0
let hexadecimal = 0x1234.5P4 // equivalent to 0x12345, or 74565.0
let hexadecimal = 0x123.45P8 // equivalent to 0x12345, or 74565.0
let hexadecimal = 0x12.345P12 // equivalent to 0x12345, or 74565.0
let hexadecimal = 0x1.2345P16 // equivalent to 0x12345, or 74565.0
let hexadecimal = 0x0.12345P20 // equivalent to 0x12345, or 74565.0
Convertir un type numérique en un autre
func doSomething1(value: Double) { /* ... */ }
func doSomething2(value: UInt) { /* ... */ }
let x = 42 // x is an Int
doSomething1(Double(x)) // convert x to a Double
doSomething2(UInt(x)) // convert x to a UInt
Les initialiseurs entiers génèrent une erreur d'exécution si la valeur déborde ou est insuffisante:
Int8(-129.0) // fatal error: floating point value cannot be converted to Int8 because it is less than Int8.min
Int8(-129) // crash: EXC_BAD_INSTRUCTION / SIGILL
Int8(-128) // ok
Int8(-2) // ok
Int8(17) // ok
Int8(127) // ok
Int8(128) // crash: EXC_BAD_INSTRUCTION / SIGILL
Int8(128.0) // fatal error: floating point value cannot be converted to Int8 because it is greater than Int8.max
La conversion de flottant en entier arrondit les valeurs à zéro :
Int(-2.2) // -2
Int(-1.9) // -1
Int(-0.1) // 0
Int(1.0) // 1
Int(1.2) // 1
Int(1.9) // 1
Int(2.0) // 2
La conversion entre nombres entiers peut être avec perte :
Int(Float(1_000_000_000_000_000_000)) // 999999984306749440
Convertir des nombres vers / depuis des chaînes
Utilisez les initialiseurs de chaîne pour convertir des nombres en chaînes:
String(1635999) // returns "1635999"
String(1635999, radix: 10) // returns "1635999"
String(1635999, radix: 2) // returns "110001111011010011111"
String(1635999, radix: 16) // returns "18f69f"
String(1635999, radix: 16, uppercase: true) // returns "18F69F"
String(1635999, radix: 17) // returns "129gf4"
String(1635999, radix: 36) // returns "z2cf"
Ou utilisez l' interpolation de chaîne pour les cas simples:
let x = 42, y = 9001
"Between \(x) and \(y)" // equivalent to "Between 42 and 9001"
Utilisez des initialiseurs de types numériques pour convertir des chaînes en nombres:
if let num = Int("42") { /* ... */ } // num is 42
if let num = Int("Z2cF") { /* ... */ } // returns nil (not a number)
if let num = Int("z2cf", radix: 36) { /* ... */ } // num is 1635999
if let num = Int("Z2cF", radix: 36) { /* ... */ } // num is 1635999
if let num = Int8("Z2cF", radix: 36) { /* ... */ } // returns nil (too large for Int8)
Arrondi
rond
Arrondit la valeur au nombre entier le plus proche avec x.5 en arrondissant (mais notez que -x.5 arrondit à la baisse).
round(3.000) // 3
round(3.001) // 3
round(3.499) // 3
round(3.500) // 4
round(3.999) // 4
round(-3.000) // -3
round(-3.001) // -3
round(-3.499) // -3
round(-3.500) // -4 *** careful here ***
round(-3.999) // -4
plafond
Arrondit n'importe quel nombre avec une valeur décimale au nombre entier supérieur suivant.
ceil(3.000) // 3
ceil(3.001) // 4
ceil(3.999) // 4
ceil(-3.000) // -3
ceil(-3.001) // -3
ceil(-3.999) // -3
sol
Arrondit tout nombre avec une valeur décimale au nombre entier inférieur.
floor(3.000) // 3
floor(3.001) // 3
floor(3.999) // 3
floor(-3.000) // -3
floor(-3.001) // -4
floor(-3.999) // -4
Int
Convertit un Double en Int , en supprimant toute valeur décimale.
Int(3.000) // 3
Int(3.001) // 3
Int(3.999) // 3
Int(-3.000) // -3
Int(-3.001) // -3
Int(-3.999) // -3
Remarques
-
round,ceiletfloorgérer à la fois l'architecture 64 et 32 bits.
Génération de nombres aléatoires
arc4random_uniform(someNumber: UInt32) -> UInt32
Cela vous donne des nombres entiers aléatoires compris entre 0 et someNumber - 1 .
La valeur maximale pour UInt32 est 4 294 967 295 (soit 2^32 - 1 UInt32 ).
Exemples:
Flip de monnaie
let flip = arc4random_uniform(2) // 0 or 1Jet de dés
let roll = arc4random_uniform(6) + 1 // 1...6Journée au hasard en octobre
let day = arc4random_uniform(31) + 1 // 1...31Année aléatoire dans les années 1990
let year = 1990 + arc4random_uniform(10)
Forme générale:
let number = min + arc4random_uniform(max - min + 1)
où number , max et min sont UInt32 .
Remarques
- Il y a un léger biais modulo avec
arc4randomdoncarc4random_uniformest préférable. - Vous pouvez
UInt32une valeurUInt32enIntmaisUInt32attention à ne pas sortir des limites.
Exponentiation
Dans Swift, nous pouvons exposer Double s avec la méthode pow() intégrée:
pow(BASE, EXPONENT)
Dans le code ci-dessous, la base (5) est mise à la puissance de l'exposant (2):
let number = pow(5.0, 2.0) // Equals 25