Swift Language
Numeri
Ricerca…
Tipi di numeri e letterali
I tipi numerici incorporati di Swift sono:
- Intestato a livello di parola (dipendente dall'architettura) Int e UInt senza segno .
- Fixed-size interi con segno int8 , Int16 , Int32 , Int64 , e interi senza segno Uint8 , UInt16 , UInt32 , UInt64 .
- Tipi floating-point Float32 / Float , Float64 / Double e Float80 (solo x86).
letterali
Un tipo di letterale numerico è dedotto dal contesto:
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
I caratteri di sottolineatura ( _ ) possono essere utilizzati per separare le cifre in valori letterali numerici. Gli zeri iniziali vengono ignorati.
I letterali in virgola mobile possono essere specificati usando le parti significante ed esponente ( «significand» e «exponent» per decimale; 0x «significand» p «exponent» per esadecimale).
Sintassi letterale intera
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
Sintassi letterale in virgola mobile
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
Converti un tipo numerico in un altro
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
Gli inizializzatori integer generano un errore di runtime se il valore trabocca o underflow:
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
Conversione da virgola mobile a valori interi arrotonda i valori verso zero :
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 conversione da intero a float potrebbe essere una perdita :
Int(Float(1_000_000_000_000_000_000)) // 999999984306749440
Converti numeri in / da stringhe
Utilizzare gli inizializzatori di stringhe per convertire i numeri in stringhe:
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"
Oppure usa l'interpolazione delle stringhe per casi semplici:
let x = 42, y = 9001
"Between \(x) and \(y)" // equivalent to "Between 42 and 9001"
Utilizza gli inizializzatori di tipi numerici per convertire stringhe in numeri:
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)
Arrotondamento
il giro
Arrotonda il valore al numero intero più vicino con l'arrotondamento di x.5 (ma nota che -x.5 arrotonda per difetto).
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
ceil
Arrotonda qualsiasi numero con un valore decimale fino al numero intero più grande successivo.
ceil(3.000) // 3
ceil(3.001) // 4
ceil(3.999) // 4
ceil(-3.000) // -3
ceil(-3.001) // -3
ceil(-3.999) // -3
pavimento
Arrotonda qualsiasi numero con un valore decimale fino al numero intero più piccolo successivo.
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
Converte un Double in un Int , lasciando cadere qualsiasi valore decimale.
Int(3.000) // 3
Int(3.001) // 3
Int(3.999) // 3
Int(-3.000) // -3
Int(-3.001) // -3
Int(-3.999) // -3
Gli appunti
-
round,ceilefloorgestiscono l'architettura a 64 e 32 bit.
Generazione di numeri casuali
arc4random_uniform(someNumber: UInt32) -> UInt32
Questo ti dà numeri casuali nell'intervallo da 0 a someNumber - 1 .
Il valore massimo per UInt32 è UInt32 (ovvero, 2^32 - 1 ).
Esempi:
Testa o croce
let flip = arc4random_uniform(2) // 0 or 1Rotolo di dadi
let roll = arc4random_uniform(6) + 1 // 1...6Random day in October
let day = arc4random_uniform(31) + 1 // 1...31Anno casuale negli anni '90
let year = 1990 + arc4random_uniform(10)
Forma generale:
let number = min + arc4random_uniform(max - min + 1)
dove number , max e min sono UInt32 .
Gli appunti
- C'è un leggero bias di modulo con
arc4randomquindi è preferitoarc4random_uniform. - Puoi lanciare un valore
UInt32su unIntmaUInt32attenzione a non andare oltre il raggio d'azione.
elevamento a potenza
In Swift, possiamo esponenziare Double s con il metodo built-in pow() :
pow(BASE, EXPONENT)
Nel codice sottostante, la base (5) è impostata sulla potenza dell'esponente (2):
let number = pow(5.0, 2.0) // Equals 25