Swift Language => 번호

숫자 유형 및 리터럴

Swift의 내장 숫자 유형은 다음과 같습니다.

Word 크기 (아키텍처에 따라 다름)로 서명 된 Int 및 부호없는 UInt .
고정 크기 부호있는 정수 Int8 , Int16 , Int32 , Int64 및 부호없는 정수 UInt8 , UInt16 , UInt32 , UInt64
플로팅 포인트 유형 Float32 / Float , Float64 / Double 및 Float80 (x86 전용).

리터럴

숫자 리터럴의 유형은 컨텍스트에서 유추됩니다.

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

밑줄 ( _ )은 숫자 리터럴에서 숫자를 분리하는 데 사용될 수 있습니다. 선행 0은 무시됩니다.

부동 소수점 리터럴은 유효 숫자 및 지수 부분 (십진수는 «significand» e «exponent» )을 사용하고 16 진수에는 0x «significand» p «exponent» 를 사용하여 지정할 수 있습니다.

정수 리터럴 구문

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

부동 소수점 리터럴 구문

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

숫자 형식을 다른 형식으로 변환

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

정수 이니셜 라이저는 값이 오버플로되거나 언더 플로우하는 경우 런타임 오류를 생성합니다.

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

부동 소수점 - 정수 변환은 값을 0으로 반올림합니다 .

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

정수에서 부동 소수로의 변환은 손실이 있을 수 있습니다.

Int(Float(1_000_000_000_000_000_000))  // 999999984306749440

숫자를 문자열로 변환하거나 문자열에서 변환

숫자를 문자열로 변환하려면 문자열 초기화기를 사용하십시오.

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"

또는 간단한 경우에는 문자열 보간 을 사용하십시오.

let x = 42, y = 9001
"Between \(x) and \(y)"  // equivalent to "Between 42 and 9001"

문자열을 숫자로 변환하려면 숫자 형식의 이니셜 라이저를 사용하십시오.

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)

반올림

일주

x.5를 반올림하여 값을 가장 가까운 정수로 반올림합니다 (단, -x.5는 반올림합니다).

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(3.000) // 3
ceil(3.001) // 4
ceil(3.999) // 4

ceil(-3.000) // -3
ceil(-3.001) // -3
ceil(-3.999) // -3

바닥

10 진수 값을 가진 모든 숫자를 다음 작은 정수로 반올림합니다.

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

Double 을 Int 변환하여 10 진수 값을 삭제합니다.

Int(3.000) // 3
Int(3.001) // 3
Int(3.999) // 3

Int(-3.000) // -3
Int(-3.001) // -3
Int(-3.999) // -3

노트

round , ceil 및 floor 모두 64 및 32 비트 아키텍처를 처리합니다.

난수 생성

arc4random_uniform(someNumber: UInt32) -> UInt32

0 에서 someNumber - 1 범위의 임의의 정수를 제공합니다.

UInt32 의 최대 값은 4,294,967,295 (즉, 2^32 - 1 )입니다.

예 :

동전 던지기

  let flip = arc4random_uniform(2) // 0 or 1

주사위 굴리기

  let roll = arc4random_uniform(6) + 1 // 1...6

10 월 임의 일

  let day = arc4random_uniform(31) + 1 // 1...31

1990 년대의 임의의 해

  let year = 1990 + arc4random_uniform(10)

일반 서식 :

let number = min + arc4random_uniform(max - min + 1)

여기서 number , max 및 min 은 UInt32 입니다.

노트

arc4random 에는 약간의 모듈러스 편차가 있으므로 arc4random_uniform 이 선호됩니다.
UInt32 값을 Int 캐스팅 할 수 있지만 범위를 벗어나는 것에주의하십시오.

지수 계산

Swift에서 우리는 내장 된 pow() 메서드를 사용하여 Double 을 exponentiate 할 수 있습니다 :

pow(BASE, EXPONENT)

아래 코드에서 base (5)는 지수 (2)의 지수로 설정됩니다.

let number = pow(5.0, 2.0) // Equals 25

Modified text is an extract of the original Stack Overflow Documentation

아래 라이선스 CC BY-SA 3.0

와 제휴하지 않음 Stack Overflow

Swift Language
번호

수색…