Swift 공식 문서 정리 - A Swift Tour

안녕하세요. 오늘은 A Swift Tour 내용을 정리해보려고 합니다. 이 글이 Swift 입문자분들께 도움이 되길 바랍니다.

📌 Hello, World!

모든 프로그래밍 언어의 첫 시작은 "Hello, World!"입니다. Swift에서는 아주 간단하게 표현할 수 있습니다.

print("Hello, world!")

print: 콘솔에 텍스트를 출력하는 Swift의 기본 함수

📌 간단한 값 (Simple Values)

상수와 변수

var myVariable = 42  // 변수 선언 (값 변경 가능)
myVariable = 50      // 값 변경 가능

let myConstant = 42  // 상수 선언 (값 변경 불가)

var: 값이 변할 수 있는 변수(variable)를 선언할 때 사용

let: 값이 변하지 않는 상수(constant)를 선언할 때 사용

타입 추론과 명시적 타입 지정

let implicitInteger = 70       // 타입 추론: Int
let implicitDouble = 70.0      // 타입 추론: Double
let explicitDouble: Double = 70 // 명시적 타입 지정(Double)

타입 추론(Type Inference): 초기값을 보고 컴파일러가 자동으로 타입을 결정하는 기능

문자열 처리와 보간법

let label = "The width is "
let width = 94
let widthLabel = label + String(width)  // 문자열 변환 후 결합

// 문자열 보간법 (String Interpolation)
let apples = 3
let appleSummary = "I have \(apples) apples."
let fruitSummary = "I have \(apples + oranges) pieces of fruit."

문자열 보간법: \(표현식) 형태로 문자열 안에 변수나 표현식을 삽입하는 기능

여러 줄 문자열

let quotation = """
        여러 줄에 걸친 문자열은
        이렇게 쌍따옴표 세 개로 시작하고 끝납니다.
        들여쓰기도 유지됩니다.
        """

여러 줄 문자열: 세 개의 쌍따옴표(""")로 감싸서 여러 줄의 문자열을 표현

배열과 딕셔너리

// 배열
var fruits = ["strawberries", "limes", "tangerines"]
fruits[1] = "grapes"  // 배열 요소 변경
fruits.append("blueberries")  // 요소 추가

// 딕셔너리
var occupations = [
    "Malcolm": "Captain",
    "Kaylee": "Mechanic",
]
occupations["Jayne"] = "Public Relations"  // 새 키-값 쌍 추가

배열(Array): 순서가 있는 값의 목록

딕셔너리(Dictionary): 키-값 쌍의 컬렉션

append(): 배열에 새 요소를 추가하는 메서드

빈 컬렉션 생성

let emptyArray: [String] = []
let emptyDictionary: [String: Float] = [:]

📌 제어 흐름 (Control Flow)

조건문 (if-else)

let individualScores = [75, 43, 103, 87, 12]
var teamScore = 0

for score in individualScores {
    if score > 50 {
        teamScore += 3
    } else {
        teamScore += 1
    }
}
print(teamScore)  // 11

if-else: 조건에 따라 코드 실행 여부를 결정하는 구문

for-in: 컬렉션의 각 항목에 대해 반복 실행하는 루프 구문

조건부 값 할당

let scoreDecoration = if teamScore > 10 {
    "🎉"
} else {
    ""
}
print("Score:", teamScore, scoreDecoration)  // Score: 11 🎉

조건부 할당: Swift에서 if 표현식을 사용해 조건에 따라 다른 값을 할당하는 방식

옵셔널 (Optionals)

var optionalString: String? = "Hello"
print(optionalString == nil)  // false

var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
if let name = optionalName {
    greeting = "Hello, \(name)"
}

옵셔널(Optional): 값이 있을 수도, 없을 수도 있음을 표현하는 타입

nil: 값이 없음을 나타내는 Swift의 특수 값

if let: 옵셔널 바인딩으로, 옵셔널에 값이 있을 경우에만 코드를 실행하는 구문

옵셔널 처리 방법들

// nil 병합 연산자
let nickname: String? = nil
let fullName: String = "John Appleseed"
let informalGreeting = "Hi \(nickname ?? fullName)"  // Hi John Appleseed

// 더 짧은 옵셔널 바인딩
if let nickname {
    print("Hey, \(nickname)")
}  // nickname이 nil이므로 아무것도 출력되지 않음

?? (Nil-Coalescing Operator): 옵셔널 값이 nil일 경우 기본값을 제공하는 연산자

Switch 문

let vegetable = "red pepper"
switch vegetable {
case "celery":
    print("Add some raisins and make ants on a log.")
case "cucumber", "watercress":
    print("That would make a good tea sandwich.")
case let x where x.hasSuffix("pepper"):
    print("Is it a spicy \(x)?")
default:
    print("Everything tastes good in soup.")
}
// 출력: "Is it a spicy red pepper?"

switch: 값을 여러 패턴과 비교하여 일치하는 패턴에 따라 코드를 실행하는 구문

case let x where: 패턴 매칭과 함께 조건을 지정하는 방식

반복문

// for-in 반복문
for (_, numbers) in interestingNumbers {
    for number in numbers {
        if number > largest {
            largest = number
        }
    }
}

// while 반복문
var n = 2
while n < 100 {
    n *= 2
}

// repeat-while 반복문 (다른 언어의 do-while과 유사)
var m = 2
repeat {
    m *= 2
} while m < 100

while: 조건이 참인 동안 코드 블록을 반복 실행

repeat-while: 코드 블록을 최소 한 번 실행한 후, 조건이 참인 동안 반복

범위 연산자

var total = 0
for i in 0..<4 {  // 0, 1, 2, 3
    total += i
}

..<: 반열린 범위 연산자로, 시작 값은 포함하고 끝 값은 제외

...: 닫힌 범위 연산자로, 시작 값과 끝 값을 모두 포함

📌 함수와 클로저 (Functions and Closures)

함수 정의와 호출

func greet(person: String, day: String) -> String {
    return "Hello \(person), today is \(day)."
}
greet(person: "Bob", day: "Tuesday")

func: 함수를 정의하는 키워드

->: 반환 타입을 지정하는 기호

Argument Label

func greet(_ person: String, on day: String) -> String {
    return "Hello \(person), today is \(day)."
}
greet("John", on: "Wednesday")

Argument Label: 함수 호출 시 매개변수 앞에 표시되는 이름

_: 인수 레이블을 사용하지 않을 때 지정하는 와일드카드 식별자

튜플 반환

func calculateStatistics(scores: [Int]) -> (min: Int, max: Int, sum: Int) {
    // 함수 구현 ...
    return (min, max, sum)
}
let statistics = calculateStatistics(scores: [5, 3, 100, 3, 9])
print(statistics.sum)  // 120
print(statistics.2)    // 120 (인덱스로도 접근 가능)

튜플(Tuple): 여러 값을 하나의 복합 값으로 그룹화하는 타입

중첩 함수

func returnFifteen() -> Int {
    var y = 10
    func add() {
        y += 5
    }
    add()
    return y
}

중첩 함수(Nested Function): 함수 내부에 정의된 함수로, 외부 함수의 변수에 접근 가능

함수를 반환하는 함수

func makeIncrementer() -> ((Int) -> Int) {
    func addOne(number: Int) -> Int {
        return 1 + number
    }
    return addOne
}
var increment = makeIncrementer()
increment(7)  // 8

고차 함수(Higher-order Function): 함수를 인자로 받거나 함수를 반환하는 함수

클로저 (Closures)

// 클로저 표현식
numbers.map({ (number: Int) -> Int in
    let result = 3 * number
    return result
})

// 간소화된 클로저 표현식
let mappedNumbers = numbers.map({ number in 3 * number })

// 더 간소화된 클로저 표현식 (암시적 파라미터 이름)
let sortedNumbers = numbers.sorted { $0 > $1 }

클로저(Closure): 코드 블록을 캡슐화하여 전달하고 사용할 수 있는 기능

$0, $1: 클로저에서 사용되는 암시적 파라미터 이름

📌 객체와 클래스 (Objects and Classes)

클래스 정의

class Shape {
    var numberOfSides = 0
    func simpleDescription() -> String {
        return "A shape with \(numberOfSides) sides."
    }
}

class: 클래스를 정의하는 키워드

프로퍼티(Property): 클래스, 구조체, 열거형에 연관된 값

클래스 인스턴스 생성과 사용

var shape = Shape()
shape.numberOfSides = 7
var shapeDescription = shape.simpleDescription()

초기화 구문

class NamedShape {
    var numberOfSides: Int = 0
    var name: String

    init(name: String) {
        self.name = name
    }
    
    // 메서드 정의...
}

init: 초기화 구문을 정의하는 키워드

self: 인스턴스 자신을 가리키는 프로퍼티

상속과 메서드 재정의

class Square: NamedShape {
    var sideLength: Double

    init(sideLength: Double, name: String) {
        self.sideLength = sideLength
        super.init(name: name)
        numberOfSides = 4
    }

    func area() -> Double {
        return sideLength * sideLength
    }

    override func simpleDescription() -> String {
        return "A square with sides of length \(sideLength)."
    }
}

상속(Inheritance): 한 클래스가 다른 클래스의 특성을 물려받는 기능

override: 상위 클래스의 메서드를 재정의하는 키워드

super: 상위 클래스의 메서드, 프로퍼티 등에 접근하는 키워드

프로퍼티 getter와 setter

class EquilateralTriangle: NamedShape {
    var sideLength: Double = 0.0
    
    // 계산 프로퍼티
    var perimeter: Double {
        get {
            return 3.0 * sideLength
        }
        set {
            sideLength = newValue / 3.0
        }
    }
    
    // 생략...
}

계산 프로퍼티(Computed Property): 값을 저장하는 대신 getter와 setter를 통해 값을 계산하는 프로퍼티

newValue: setter에서 새로 설정되는 값을 의미하는 기본 매개변수 이름

프로퍼티 옵저버

class TriangleAndSquare {
    var triangle: EquilateralTriangle {
        willSet {
            square.sideLength = newValue.sideLength
        }
    }
    var square: Square {
        willSet {
            triangle.sideLength = newValue.sideLength
        }
    }
    // 생략...
}

willSet: 프로퍼티 값이 변경되기 직전에 호출되는 옵저버

didSet: 프로퍼티 값이 변경된 직후에 호출되는 옵저버

옵셔널 체이닝

let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square")
let sideLength = optionalSquare?.sideLength

옵셔널 체이닝(Optional Chaining): 옵셔널 값이 nil이 아닐 때만 프로퍼티, 메서드 등에 접근하는 기능

📌 열거형과 구조체 (Enumerations and Structures)

열거형 정의와 사용

enum Rank: Int {
    case ace = 1
    case two, three, four, five, six, seven, eight, nine, ten
    case jack, queen, king
    
    func simpleDescription() -> String {
        // 메서드 구현...
    }
}
let ace = Rank.ace
let aceRawValue = ace.rawValue  // 1

enum: 열거형을 정의하는 키워드

case: 열거형의 각 케이스를 정의하는 키워드

rawValue: 열거형 케이스의 원시 값에 접근하는 프로퍼티

연관 값을 가진 열거형

enum ServerResponse {
    case result(String, String)
    case failure(String)
}

let success = ServerResponse.result("6:00 am", "8:09 pm")

switch success {
case let .result(sunrise, sunset):
    print("Sunrise is at \(sunrise) and sunset is at \(sunset).")
case let .failure(message):
    print("Failure... \(message)")
}

연관 값(Associated Value): 열거형 케이스가 저장할 수 있는 추가 정보

구조체 정의와 사용

struct Card {
    var rank: Rank
    var suit: Suit
    
    func simpleDescription() -> String {
        return "The \(rank.simpleDescription()) of \(suit.simpleDescription())"
    }
}
let threeOfSpades = Card(rank: .three, suit: .spades)

struct: 구조체를 정의하는 키워드

구조체와 클래스의 차이점: 구조체는 값 타입이고, 클래스는 참조 타입

📌 동시성 (Concurrency)

비동기 함수

func fetchUserID(from server: String) async -> Int {
    if server == "primary" {
        return 97
    }
    return 501
}

async: 비동기 함수를 선언하는 키워드

비동기 함수: 실행을 일시 중단하고 나중에 다시 시작할 수 있는 함수

비동기 함수 호출

func fetchUsername(from server: String) async -> String {
    let userID = await fetchUserID(from: server)
    // 생략...
}

await: 비동기 함수를 호출하고 결과를 기다리는 키워드

병렬 비동기 작업

func connectUser(to server: String) async {
    async let userID = fetchUserID(from: server)
    async let username = fetchUsername(from: server)
    let greeting = await "Hello \(username), user ID \(userID)"
    print(greeting)
}

async let: 비동기 작업을 병렬로 시작하는 구문

TaskGroup

let userIDs = await withTaskGroup(of: Int.self) { group in
    for server in ["primary", "secondary", "development"] {
        group.addTask {
            return await fetchUserID(from: server)
        }
    }
    
    // 결과 수집...
}

withTaskGroup: 여러 비동기 작업을 그룹화하여 관리하는 함수

액터 (Actor)

actor ServerConnection {
    var server: String = "primary"
    private var activeUsers: [Int] = []
    
    func connect() async -> Int {
        let userID = await fetchUserID(from: server)
        activeUsers.append(userID)
        return userID
    }
}

actor: 동시성 컨텍스트에서 안전하게 상태를 공유할 수 있는 참조 타입

📌 프로토콜과 확장 (Protocols and Extensions)

프로토콜 정의

protocol ExampleProtocol {
    var simpleDescription: String { get }
    mutating func adjust()
}

protocol: 프로토콜을 정의하는 키워드

{ get }: 읽기 전용 프로퍼티를 나타내는 지정자

mutating: 구조체나 열거형 메서드가 self를 수정할 수 있음을 나타내는 키워드

프로토콜 채택

class SimpleClass: ExampleProtocol {
    var simpleDescription: String = "A very simple class."
    var anotherProperty: Int = 69105
    func adjust() {
        simpleDescription += "  Now 100% adjusted."
    }
}

struct SimpleStructure: ExampleProtocol {
    var simpleDescription: String = "A simple structure"
    mutating func adjust() {
        simpleDescription += " (adjusted)"
    }
}

확장 (Extension)

extension Int: ExampleProtocol {
    var simpleDescription: String {
        return "The number \(self)"
    }
    mutating func adjust() {
        self += 42
    }
}
print(7.simpleDescription)  // "The number 7"

extension: 기존 타입에 새로운 기능을 추가하는 키워드

📌 에러 처리 (Error Handling)

에러 정의

enum PrinterError: Error {
    case outOfPaper
    case noToner
    case onFire
}

Error: Swift의 에러 처리 메커니즘을 위한 프로토콜

throws 키워드와 에러 던지기

func send(job: Int, toPrinter printerName: String) throws -> String {
    if printerName == "Never Has Toner" {
        throw PrinterError.noToner
    }
    return "Job sent"
}

throws: 함수가 에러를 던질 수 있음을 나타내는 키워드

throw: 에러를 발생시키는 키워드

do-catch로 에러 처리

do {
    let printerResponse = try send(job: 1040, toPrinter: "Bi Sheng")
    print(printerResponse)
} catch {
    print(error)
}

do-catch: 에러를 처리하는 구문

try: 에러를 던질 수 있는 함수 호출에 사용하는 키워드

다양한 에러 처리 방법

// try? - 옵셔널 결과 반환
let printerSuccess = try? send(job: 1884, toPrinter: "Mergenthaler")

// defer - 함수 종료 시 실행되는 코드 블록
func fridgeContains(_ food: String) -> Bool {
    fridgeIsOpen = true
    defer {
        fridgeIsOpen = false
    }
    // 함수 구현...
}

try?: 에러가 발생하면 nil을 반환하는 에러 처리 방식

defer: 함수가 종료될 때 실행되는 코드 블록을 정의하는 키워드

📌 제너릭 (Generics)

제너릭 함수

func makeArray<Item>(repeating item: Item, numberOfTimes: Int) -> [Item] {
    var result = [Item]()
    for _ in 0..<numberOfTimes {
        result.append(item)
    }
    return result
}
makeArray(repeating: "knock", numberOfTimes: 4)

제너릭(Generic): 타입에 유연하게 작동하는 코드를 작성할 수 있게 해주는 기능

<Item>: 타입 매개변수를 정의하는 구문

제너릭 타입

enum OptionalValue<Wrapped> {
    case none
    case some(Wrapped)
}
var possibleInteger: OptionalValue<Int> = .none

제약 조건 추가

func anyCommonElements<T: Sequence, U: Sequence>(_ lhs: T, _ rhs: U) -> Bool
    where T.Element: Equatable, T.Element == U.Element
{
    // 함수 구현...
}

where 절: 제네릭 타입에 제약 조건을 추가하는 구문

Sequence: 요소에 순차적으로 접근할 수 있는 타입을 정의하는 프로토콜

Equatable: 값의 동등성을 비교할 수 있는 타입을 정의하는 프로토콜

---

이상으로 Swift 언어의 기본 문법부터 고급 기능까지 핵심 내용을 살펴보았습니다. Swift는 안전성, 성능, 표현력을 모두 갖춘 현대적인 프로그래밍 언어로, iOS, macOS, watchOS, tvOS 애플리케이션 개발에 사용됩니다.