[Swift] 기본 (The Basics)

참고 자료

기본 (The Basics) - Swift

 

Swift 공식 문서를 한국어로 번역한 사이트입니다.

💻  참고 자료의 모든 내용을 다루는 것이 아니라 공부하면서 새롭게 알게 된 점 위주로 정리했습니다. 또한, 참고 자료이외에도 추가적으로 공부한 부분도 정리했습니다.

---

 

상수와 변수 (Constants and Variables)

여러 개의 상수 또는 여러 개의 변수를 선언할 때 콤마로 구분하여 한줄로 선언이 가능하다.

var x = 0.0, y = 0.0, z = 0.0

 

타입 명시 (Type Annotations)

var welcomeMessage1: String // 타입 명시
var welcomeMessage2 = "Welcome!" // 타입 추론

 

타입 추론 vs 타입 명시

간혹 타입 추론과 타입 명시의 차이를 설명하면서 둘 간의 속도 비교를 하는 글들이 존재한다. 타입 추론의 경우 '타입 명시와 비교하여 Swift 컴파일러가 해당 상수나 변수의 타입을 추론하는 데에 시간이 더 걸리지 않을까' 라는 궁금증 때문에 이러한 속도 비교를 한 것 같다.

하지만, 대부분의 글들이 아래와 같은 코드로 실행시간을 비교하고 있었다. 

func measureTime(_ closure: () -> ()) -> TimeInterval {
    let startDate = Date()
    closure()
    return Date().timeIntervalSince(startDate)
}

// 타입 추론 시간 체크
measureTime {
  for i in 1...1000000 {
      let num = 0 + i
  }
}

// 타입 명시 시간 체크
measureTime {
  for i in 1...1000000 {
      let num: Int = 0 + i
  }
}

 

하지만, 이러한 테스트 코드는 컴파일 시간을 체크하는 것이 아니라 런타임에서의 실행 시간을 체크하는 코드이다. num 상수가 반복문을 돌 때마다 새로 생성되어지는 것은 맞지만 런타임에는 num 상수의 초기값만 결정되고, Swift는 정적타입 언어라 컴파일 시간에 num 상수의 타입이 이미 결정되기 때문에 테스트의 궁극적 목적인 'Swift 컴파일러가 타입을 결정하기까지의 시간 차이' 에서는 벗어나는 테스트 코드이다.

 

그러면 컴파일 속도 차이는 어떨까? 결론은 오히려 타입 추론이 더 빠른 컴파일 속도를 보인다고 한다. 이유는 다음과 같다.

Swift 컴파일러는 최적화 기능이 잘 되어있어 애초에 타입 추론과 타입 명시간의 컴파일 성능 차이가 굉장히 미미하고, 타입 명시가 오히려 명시된 타입과 초기값을 비교하는 작업이 추가되어 조금 더 느리다고 한다. 

 

타입 추론과 타입 어노테이션의 속도 차이에 관하여(🧐 타입 추론이 더 빠르다?)

 

타입 추론과 타입 명시의 사용 판단 기준

결론부터 말하자면, 사용 판단 기준은 개인 스타일 혹은 팀에서 사용하는 컨벤션에 따라 달라질 수 있다. 즉, 컴파일 시간이 크리티컬한 이슈가 될 정도로 사이즈가 거대한 프로젝트이면 되도록 타입 추론을 사용하는 것이 좋지만, 그것이 아니라면 뭘 사용해도 상관없다는 것이다.

 

하지만, 꼭 타입 명시를 사용해야 할 경우가 있다.

• 초기값과 다른 타입을 사용하기를 원할 때

let one = 1
print(type(of: one)) // Int

let two: Double = 2
print(two) // 2.0

let a = "A"
print(type(of: a)) // String

let b: Character = "B"
print(type(of: b)) // Character

 

• 상수나 변수를 선언은 했지만, 아직 값을 할당하고 싶지 않을 때

var totalWeight: Int
let leftDumbbellWeigth = 10
let rightDumbbellWeight = 10
let isAssemble = true

if isAssemble {
   totalWeigth = leftDumbbellWeigth + rightDumbbellWeight
} else {
   totalWeigth = 0
}

 

위 두 가지 상황이 아닐 때에는 타입 추론을 사용하든 타입 명시를 사용하든 어디까지나 개인의 스타일이다. 필자는 협업을 할 때 중요한 역할을 하는 상수나 변수에는 타입 명시를 사용하고 별로 중요하지 않은 상수나 변수에는 타입 추론을 사용한다.

 

세미콜론

많은 언어와 다르게 Swift는 코드의 각 구문 뒤에 세미콜론이 필수가 아니다. 그러나 여러 구문을 한줄로 작성할 경우 세미콜론은 필수로 작성되어야한다.

let cat = "🐱"; print(cat)
// Prints "🐱"

 

 

정수

• 부호 있는 정수 타입

Int8, Int32, Int64, Int

 

Int는 32-bit 플랫폼에서는 Int32, 64-bit 플랫폼에서는 Int64와 같은 크기를 가진다.

 

• 부호 없는 정수 타입

UInt8, UInt32, UInt64, UInt

 

UInt도 Int와 동일하게 플랫폼에 따라 자동으로 맞춤형 크기를 가진다.

 

• 각 타입이 표현할 수 있는 최대, 최소값 확인

print(Int.max) // 9223372036854775807 (64-bit 플랫폼에서의 최대 크기 == Int64.max)
print(Int.min) // -9223372036854775808

print(Int32.max) // 2147483647
print(Int32.min) // -2147483648

print(UInt8.max) // 255
print(UInt8.min) // 0

 

※ 왜 음수가 양수보다 표현값이 하나 더 많은가

컴퓨터에서는 음수를 2의 보수로 표현한다. 이진수의 음수 표현 방식 중 부호와 절댓값, 1의 보수는 0을 +0, -0과 같이 두 가지로 표현 한다. 즉, 부호 비트가 0일 때와 부호 비트가 1일 때 0을 의미하는 이진수가 둘 다 존재한다는 것이다. 반면, 2의 보수는 부호 비트가 0일 때 0을 의미하는 이진수만 존재한다. 따라서, 자연스레 부호 비트가 1인 경우에 표현할 수 있는 값이 하나 더 늘게 된다. (8bit인 경우 10000000)

 

• 정수 리터럴

let decimalInteger = 17
let binaryInteger = 0b10001       // 17의 이진수 표기법
let octalInteger = 0o21           // 17의 8진수 표기법
let hexadecimalInteger = 0x11     // 17의 16진수 표기법

let oneMillion = 1_000_000        // 가독성을 위한 밑줄 포함 가능

 

 

부동 소수점 숫자

• Double 
  
  • 64-bit 부동 소수점 숫자 표기
  • 최소 15자리 소수점 정확도
• Float
  • 32-bit 부동 소수점 숫자 표기
  • 최소 6자리 정확도

※ 부동 소수점

컴퓨터에서 이진 소수를 다룰 때에는 두 가지 방식이 존재한다. 첫 번째는 32-bit 기준 최상위 1비트를 부호, 그 다음 15비트를 정수부, 남은 16비트를 소수부로 표현하는 고정 소수점 방식이다. 이러한 고정 소수점 방식은 다룰 수 있는 비트의 수가 한정되어있어 더 많은 표현을 할 수 없다는 문제가 발생한다.

 

이러한 문제점을 해결한 방식이 바로 부동 소수점이다. 먼저, 십진 소수를 이진 소수로 바꾼 것을 정규화를 거친다. 정규화된 이진 소수는 ±(1.가수부)×2^지수부-127 로 표현된다. 이 정규화를 거친 수를 32-bit 기준 최상위 1비트를 부호, 그 다음 8비트를 지수부, 남은 23비트를 가수부로 표현하는 방식으로 더 많은 표현을 할 수 있게 된다.

 

Float형이 32-bit 부동 소수점 숫자를 표기하는데 사용되고, Double형이 64-bit 부동 소수점 숫자를 표기한다. 64-bit 부동 소수점은 최상위 1비트를 부호, 그 다음 11비트를 지수부, 남은 52비트를 가수부로 표현하여 Float형보다 더 높은 정밀도를 가지고 소수를 표현할 수 있다.

 

※ 부동 소수점 오차

print(1.1 + 0.1 == 1.2) // false

 

Swift 뿐만 아니라 IEEE 754 표준 부동 소수점 방식을 사용하고 있는 모든 프로그래밍 언어에서는 위와 같은 결과가 나온다. 왜냐하면, 부동 소수점을 이용하여 소수를 표현할 때 오차가 생기기 때문이다.

 

오차가 생기는 이유는 간단하다. 1/3을 십진 소수점으로 표현하면 0.3333... 과 같이 무한소수로 표현되는 것처럼 다른 진법에서도 무한소수가 되는 수들이 존재한다. 이진법 같은 경우에는 십진수 0.1을 이진 소수점으로 표현하면 0.001100110011... 과 같이 무한소수로 표현된다. 이러한 무한소수를 컴퓨터에서 다룰려면 32-bit(Float) 혹은 64-bit(Double)로 다뤄야 하는데 당연히 32bit 혹은 64bit 이후의 값들이 생략되기 때문에 오차가 발생할 수 밖에 없다.

 

더욱 쉽게 얘기하면 다음과 같다. 중고등학교 수학 문제를 풀 때 보통 무한소수인 π의 값을 3.14라 지정하고 계산을 하게된다. 따라서, π + 1 = 4.14 이지만, 실제로는 그렇지 않고 생략된 소수점만큼 오차가 생긴다. 이러한 일들이 컴퓨터 내에서도 벌어지고 있다고 생각하면 이해하기 쉬울 것 같다.

 

따라서, 소수를 다루는 프로그래밍은 이러한 오차를 항상 염두해두고 있어야한다.

 

• 부동 소수점 리터럴

let decimalDouble = 12.1875
let exponentDouble = 1.21875e1	// 12.1875를 지수가 1인 10진수로 표기

let paddedDouble = 000123.456   // 앞부분에 0을 채워도 문제 없음
let justOverOneMillion = 1_000_000.000_000_1  // 소수부도 마찬가지로 가독성을 위해 밑줄 포함 가능

 

• 정수와 부동 소수점 변환

let pi = 3.14159 // Double로 타입 추론
let anotherPi = 3 + 0.14159 // 마찬가지로 Double로 타입 추론

let three = 3 // Int로 타입 추론
let pointOneFourOneFiveNine = 0.14159 // Double로 타입 추론
let pi = three + pointOneFourOneFiveNine // Error: Int + Double 불가
let pi = Double(three) + pointOneFourOneFiveNine // 3.14159

let integerPi = Int(pi) // 3

 

각각 다른 타입끼리의 연산은 불가하여 서로 같은 타입끼리의 연산이 되게 변환해야 한다. 이때, 부동 소수점 값은 정수 값으로 초기화할 때 소수점 아래를 버림한다. 예를 들어, 4.75는 4, -3.9는 -3이 된다.

 

튜플

튜플은 하나의 튜플에 각각 다른 타입의 값들을 담을 수 있어 반환 값이 여러 개인 함수에 유용하게 사용된다.

 

• 튜플의 분해(decompose)

let http404Error = (404, "Not Found")

let (statusCode, statusMessage) = http404Error
print("The status code is \(statusCode)") // 404
print("The status message is \(statusMessage)") // Not Found

let (justTheStatusCode, _) = http404Error // _ 을 사용하여 무시할 수 있음
print("The status code is \(justTheStatusCode)")

// 인덱스를 사용하여 튜플의 개별 요소 접근
print("The status code is \(http404Error.0)") // 404
print("The status message is \(http404Error.1)") // Not Found

 

• Named Tuple

let http200Status = (statusCode: 200, description: "OK")

print("The status code is \(http200Status.statusCode)") // 200
print("The status message is \(http200Status.description)") // OK

print(type(of: http200Status)) // (statusCode: Int, description: String)

 

옵셔널

옵셔널은 Swift 언어의 꽃이라 할 수 있으므로 조금 더 자세하게 다루고 싶어 다른 글을 참고해주길 바란다.

 

에러 처리

func canThrowAnError() throws {
    // this function may or may not throw an error
}

 

throws 키워드를 사용하여 해당 함수는 에러가 발생할 수 있음을 나타내야 한다. 에러가 발생할 수 있는 함수를 호출할 때는 표현식 앞에 try 키워드를 붙여야 한다. 함수 호출을 do 구문으로 래핑하면 에러가 발생할 때 catch 절로 전파된다.

 

func makeASandwich() throws {
    // ...
}

do {
    try makeASandwich()
    eatASandwich()
} catch SandwichError.outOfCleanDishes {
    washDishes()
} catch SandwichError.missingIngredients(let ingredients) {
    buyGroceries(ingredients)
}

 

자세한 에러 발생, 포착, 전파는 에러 처리 파트에서 다룰 것이다.

 

역설과 전제조건

역설과 전제조건은 런타임시 추가 코드를 실행하기 전에 필수 조건이 충족되는 지 확인할 수 있는 디버깅 문법이다. 역설은 오직 디버그 빌드에서만 체크되고, 전제조건은 디버그와 프로덕션 빌드 모두에서 체크된다. 즉, 역설은 개발 중에 실수나 잘못된 가정을 찾는 데 도움이 되고 전제조건은 프로덕션에서 이슈를 발견하는 데 도움이 된다.

 

• 역설을 통한 디버깅

let age = -3
assert(age >= 0, "A person's age can't be less than zero.")
// 프로그램 종료 후 "Assertion failed: A person's age can't be less than zero." 에러 메서지 출력

 

 

코드가 이미 조건이 체크되었다면 assertionFailure() 함수를 사용하여 출력할 에러 메세지를 작성할 수 있다.

 

if age > 10 {
    print("You can ride the roller-coaster or the ferris wheel.")
} else if age >= 0 {
    print("You can ride the ferris wheel.")
} else {
    assertionFailure("A person's age can't be less than zero.")
}

 

• 전제조건

let array = [1, 2, 3, 4]
let index = -1

precondition(index > 0, "Index must be greater than zero.")
// 프로그램 종료 후 "Precondition failed: Index must be greater than zero." 에러 메시지 출력
print(array[index])

 

마찬가지로, 이미 조건이 체크되었다면 preconditionFailure() 함수를 사용하여 출력할 에러 메세지를 작성할 수 있다.