Swift Language
Liczby
Szukaj…
Typy liczb i literały
Wbudowane typy numeryczne Swift to:
- Rozmiar słowa (zależny od architektury) podpisany Int i niepodpisany UInt .
- Liczby całkowite ze stałym rozmiarem Int8 , Int16 , Int32 , Int64 i liczby całkowite bez znaku UInt8 , UInt16 , UInt32 , UInt64 .
- Typy zmiennoprzecinkowe Float32 / Float , Float64 / Double i Float80 (tylko x86).
Literały
Typ literału numerycznego wywodzi się z kontekstu:
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
Podkreślenia ( _ ) mogą być użyte do oddzielenia cyfr literałów numerycznych. Zera wiodące są ignorowane.
Literały zmiennoprzecinkowe można określić za pomocą części znaczącej i wykładniczej ( «significand» e «exponent» dla dziesiętnych; 0x «significand» p «exponent» dla szesnastkowej).
Liczba całkowita dosłowna
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
Dosłowna składnia zmiennoprzecinkowa
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
Konwertuj jeden typ liczbowy na inny
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
Inicjatory liczb całkowitych powodują błąd czasu wykonywania, jeśli wartość przepełnia się lub niedopełnia:
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
Konwersja liczby zmiennoprzecinkowej na liczbę całkowitą zaokrągla wartości do zera :
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
Konwersja liczb całkowitych na zmiennoprzecinkowe może być stratna :
Int(Float(1_000_000_000_000_000_000)) // 999999984306749440
Konwertuj liczby na / z ciągów
Użyj inicjatorów ciągu do konwertowania liczb na ciągi:
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"
Lub użyj interpolacji ciągów dla prostych przypadków:
let x = 42, y = 9001
"Between \(x) and \(y)" // equivalent to "Between 42 and 9001"
Użyj inicjatorów typów numerycznych, aby przekonwertować ciągi na liczby:
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)
Zaokrąglanie
okrągły
Zaokrągla wartość do najbliższej liczby całkowitej zaokrąglając x.5 w górę (ale zauważ, że -x.5 zaokrągla w dół).
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
stropować
Zaokrągla dowolną liczbę o wartości dziesiętnej do następnej większej liczby całkowitej.
ceil(3.000) // 3
ceil(3.001) // 4
ceil(3.999) // 4
ceil(-3.000) // -3
ceil(-3.001) // -3
ceil(-3.999) // -3
piętro
Zaokrągla dowolną liczbę o wartości dziesiętnej w dół do następnej mniejszej liczby całkowitej.
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
Konwertuje Double na Int , upuszczając dowolną wartość dziesiętną.
Int(3.000) // 3
Int(3.001) // 3
Int(3.999) // 3
Int(-3.000) // -3
Int(-3.001) // -3
Int(-3.999) // -3
Notatki
-
round,ceilifloorobsługują zarówno architekturę 64-, jak i 32-bitową.
Generowanie liczb losowych
arc4random_uniform(someNumber: UInt32) -> UInt32
Daje to losowe liczby całkowite z zakresu od 0 do someNumber - 1 .
Maksymalna wartość dla UInt32 wynosi 4 294 967 UInt32 (to znaczy 2^32 - 1 UInt32 ).
Przykłady:
Rzut monetą
let flip = arc4random_uniform(2) // 0 or 1Rzut kostką
let roll = arc4random_uniform(6) + 1 // 1...6Losowy dzień w październiku
let day = arc4random_uniform(31) + 1 // 1...31Losowy rok w latach 90
let year = 1990 + arc4random_uniform(10)
Ogólna forma:
let number = min + arc4random_uniform(max - min + 1)
gdzie number , max i min to UInt32 .
Notatki
- Z
arc4randomistnieje niewielkie odchylenie modulo, więc preferowany jestarc4random_uniform. - Możesz rzucić wartość
UInt32naIntale uważaj na wyjście poza zasięg.
Potęgowanie
W Swift możemy potęgować Double s za pomocą wbudowanej metody pow() :
pow(BASE, EXPONENT)
W poniższym kodzie podstawa (5) jest ustawiona na potęgę wykładnika (2):
let number = pow(5.0, 2.0) // Equals 25