Swift 공식 문서 정리 - 기본(The Basics)(2/2)

안녕하세요 이번에는 Swift 기본 개념 정리의 두 번째 파트로, 부울, 튜플, 옵셔널, 에러 처리 등 중요한 개념들을 알아보겠습니다.

📌 부울 (Booleans)

Swift는 참과 거짓을 표현하기 위한 Bool 타입을 제공합니다:

let orangesAreOrange = true
let turnipsAreDelicious = false

// 조건문에서 사용
if turnipsAreDelicious {
    print("Mmm, tasty turnips!")
} else {
    print("Eww, turnips are horrible.")
}
// "Eww, turnips are horrible." 출력

Bool: 참(true) 또는 거짓(false) 값만 가질 수 있는 논리 타입입니다.

Swift는 타입 안전성을 위해 부울이 아닌 값이 Bool로 대체되는 것을 방지합니다:

let i = 1
if i == 1 {
    // 올바른 사용: 비교 결과는 Bool 타입
}

// 다음 코드는 컴파일 에러 발생
// if i { ... }  // 잘못된 사용: i는 Bool이 아님

📌 튜플 (Tuples)

튜플은 여러 값을 하나의 복합 값으로 그룹화합니다:

// HTTP 상태 코드를 나타내는 튜플
let http404Error = (404, "Not Found")
// 타입은 (Int, String)

// 튜플 분해(decompose)하기
let (statusCode, statusMessage) = http404Error
print("상태 코드: \(statusCode)")  // "상태 코드: 404" 출력
print("상태 메시지: \(statusMessage)")  // "상태 메시지: Not Found" 출력

// 일부 값만 필요할 때
let (justTheStatusCode, _) = http404Error

// 인덱스로 접근
print("상태 코드: \(http404Error.0)")  // "상태 코드: 404" 출력

// 이름이 있는 튜플 요소
let http200Status = (statusCode: 200, description: "OK")
print("상태 코드: \(http200Status.statusCode)")  // "상태 코드: 200" 출력

튜플(Tuple): 여러 타입의 값을 하나로 묶은 복합 타입으로, 함수에서 여러 값을 반환할 때 유용합니다.

📌 옵셔널 (Optionals)

옵셔널은 값이 없을 수 있는 상황을 안전하게 처리하기 위한 Swift의 핵심 기능입니다:

let possibleNumber = "123"
let convertedNumber = Int(possibleNumber)
// convertedNumber는 Int? 타입 (옵셔널 Int)

옵셔널(Optional): 값이 있거나 없을 수 있는 상황을 표현하는 타입으로, 타입 뒤에 물음표(?)를 붙여 표현합니다.

nil

nil은 값이 없음을 나타내는 특수한 값입니다:

var serverResponseCode: Int? = 404
serverResponseCode = nil  // 값 없음으로 설정

// 초기값 없이 선언된 옵셔널은 자동으로 nil
var surveyAnswer: String?  // nil로 초기화됨

nil: 값이 없음을 나타내는 Swift의 특수 값입니다. 옵셔널 타입만 nil을 가질 수 있습니다.

옵셔널 바인딩 (Optional Binding)

옵셔널에 값이 있는지 확인하고 있다면 해당 값을 임시 변수나 상수로 사용할 수 있게 합니다:

if let actualNumber = Int(possibleNumber) {
    print("문자열 \"\(possibleNumber)\"은 정수값 \(actualNumber)입니다.")
} else {
    print("문자열 \"\(possibleNumber)\"을 정수로 변환할 수 없습니다.")
}
// "문자열 "123"은 정수값 123입니다." 출력

// 더 짧은 형태의 옵셔널 바인딩 (Swift 5.7+)
let myNumber: Int? = Int(possibleNumber)
if let myNumber {
    print("숫자는 \(myNumber)입니다.")
}
// "숫자는 123입니다." 출력

// 여러 옵셔널 바인딩 함께 사용
if let firstNumber = Int("4"), let secondNumber = Int("42"), firstNumber < secondNumber {
    print("\(firstNumber) < \(secondNumber)")
}
// "4 < 42" 출력

옵셔널 바인딩: 옵셔널에 값이 있는지 확인하고, 있다면 그 값을 임시 상수나 변수로 추출하는 방법입니다.

대체값 제공 (Nil-Coalescing Operator)

nil-결합 연산자(??)를 사용하여 옵셔널이 nil일 경우 기본값을 제공할 수 있습니다:

let name: String? = nil
let greeting = "안녕하세요, " + (name ?? "친구") + "!"
print(greeting)
// "안녕하세요, 친구!" 출력

nil-결합 연산자(??): 옵셔널이 nil이면 기본값을 제공하는 연산자입니다.

강제 언래핑 (Force Unwrapping)

옵셔널에 값이 있다고 확신할 때 느낌표(!)를 사용하여 강제로 값을 추출할 수 있습니다:

let possibleNumber = "123"
let convertedNumber = Int(possibleNumber)

// 강제 언래핑 - 옵셔널에 값이 없으면 런타임 에러 발생
let number = convertedNumber!

강제 언래핑: 옵셔널에서 값을 강제로 추출하는 방법으로, 옵셔널이 nil이면 런타임 에러가 발생합니다.

암시적으로 언래핑된 옵셔널 (Implicitly Unwrapped Optionals)

암시적으로 언래핑된 옵셔널은 처음 정의된 후 항상 값이 있다고 가정할 수 있을 때 유용합니다:

let possibleString: String? = "옵셔널 문자열입니다."
let forcedString: String = possibleString!  // 명시적 언래핑 필요

let assumedString: String! = "암시적으로 언래핑된 옵셔널 문자열입니다."
let implicitString: String = assumedString  // 자동으로 언래핑됨

암시적으로 언래핑된 옵셔널: 타입 뒤에 느낌표(!)를 붙여 선언하며, 접근할 때마다 자동으로 언래핑됩니다.

📌 에러 처리 (Error Handling)

Swift는 프로그램 실행 중 발생할 수 있는 에러를 처리하기 위한 메커니즘을 제공합니다:

// 에러 정의
enum PrinterError: Error {
    case outOfPaper
    case noToner
    case onFire
}

// 에러를 발생시킬 수 있는 함수
func send(job: Int, toPrinter printerName: String) throws -> String {
    if printerName == "Never Has Toner" {
        throw PrinterError.noToner
    }
    return "작업이 전송되었습니다."
}

// 에러 처리
do {
    let printerResponse = try send(job: 1040, toPrinter: "Bi Sheng")
    print(printerResponse)
} catch {
    print(error)
}
// "작업이 전송되었습니다." 출력

// 여러 catch 블록으로 다양한 에러 처리
do {
    let printerResponse = try send(job: 1440, toPrinter: "Never Has Toner")
    print(printerResponse)
} catch PrinterError.onFire {
    print("프린터가 불타고 있습니다!")
} catch let printerError as PrinterError {
    print("프린터 에러: \(printerError).")
} catch {
    print("에러: \(error)")
}
// "프린터 에러: noToner." 출력

// try?를 사용하여 옵셔널 결과 반환
let printerSuccess = try? send(job: 1884, toPrinter: "Mergenthaler")
// 성공 시 String?, 실패 시 nil

Error 프로토콜: Swift에서 에러 타입은 Error 프로토콜을 준수해야 합니다.

throws: 함수가 에러를 발생시킬 수 있음을 나타내는 키워드입니다.

throw: 에러를 발생시키는 키워드입니다.

try: 에러를 발생시킬 수 있는 함수 호출 시 사용하는 키워드입니다.

do-catch: 에러를 포착하고 처리하는 구문입니다.

📌 역설과 전제조건 (Assertions and Preconditions)

런타임에 조건을 확인하여 코드가 올바르게 실행되도록 보장하는 방법입니다:

역설 (Assertions)

역설은 디버그 빌드에서만 확인되며, 조건이 false면 앱이 종료됩니다:

let age = -3
assert(age >= 0, "나이는 음수가 될 수 없습니다.")
// 이 역설은 실패하며, 앱이 종료됩니다.

// 메시지 없이 사용
assert(age >= 0)

// 이미 조건이 체크된 경우
if age > 10 {
    print("롤러코스터나 관람차를 탈 수 있습니다.")
} else if age >= 0 {
    print("관람차를 탈 수 있습니다.")
} else {
    assertionFailure("나이는 음수가 될 수 없습니다.")
}

assert: 디버그 빌드에서 조건을 확인하고, 조건이 false면 앱을 종료하는 함수입니다.

assertionFailure: 조건 확인 없이 바로 앱을 종료하는 함수입니다.

전제조건 (Preconditions)

전제조건은 디버그와 프로덕션 빌드 모두에서 확인됩니다:

// 인덱스가 배열 범위 내에 있는지 확인
precondition(index > 0, "인덱스는 0보다 커야 합니다.")

// 구현되지 않은 기능에 사용
func fetchData() -> [String] {
    if useMockData {
        return ["테스트 데이터"]
    } else {
        preconditionFailure("아직 구현되지 않았습니다.")
    }
}

precondition: 디버그와 프로덕션 빌드 모두에서 조건을 확인하고, 조건이 false면 앱을 종료하는 함수입니다.

preconditionFailure: 조건 확인 없이 바로 앱을 종료하는 함수입니다.

fatalError: 최적화 설정과 관계없이 항상 앱을 종료하는 함수입니다.

📌 요약

Swift의 기본 개념 중 주요 내용을 정리했습니다:

• 부울(Bool): 참/거짓 값을 표현하는 논리 타입
• 튜플(Tuple): 여러 값을 하나의 복합 값으로 그룹화
• 옵셔널(Optional): 값이 있거나 없을 수 있는 상황을 안전하게 처리
  • nil: 값이 없음을 나타내는 특수 값
  • 옵셔널 바인딩: if let을 사용해 옵셔널 값을 안전하게 추출
  • nil-결합 연산자(??): 기본값 제공
  • 강제 언래핑(!): 옵셔널에서 값을 강제로 추출
• 에러 처리: do-try-catch 구문을 사용한 에러 처리 메커니즘
• 역설과 전제조건: 런타임에 코드의 조건을 확인하는 방법