Swift 공식 문서 정리 - 클로저 (Closures)

안녕하세요. 이번 포스트에서는 클로저(Closures)에 대해 알아보겠습니다. 

📌 클로저란?

클로저는 코드에서 전달하고 사용할 수 있는 자체 포함된 기능 블록입니다. C나 Objective-C의 블록(blocks), 다른 언어의 람다(lambdas)와 유사한 개념입니다.

클로저(Closure): 독립적인 코드 블록으로, 함수처럼 작동하지만 이름이 없을 수도 있으며 주변 컨텍스트의 값을 캡처할 수 있습니다.

Swift에서 클로저는 세 가지 형태로 나타납니다:

1. 전역 함수: 이름이 있고 어떤 값도 캡처하지 않는 클로저
2. 중첩 함수: 이름이 있고 둘러싼 함수에서 값을 캡처할 수 있는 클로저
3. 클로저 표현식: 이름이 없고 주변 컨텍스트에서 값을 캡처할 수 있는 경량 구문

📌 클로저 표현식 구문

클로저 표현식은 간결한 인라인 구문으로 클로저를 작성하는 방법입니다. 기본 구문은 다음과 같습니다:

{ (parameters) -> ReturnType in
    statements
}

이 개념을 설명하기 위해 배열 정렬 예제를 살펴보겠습니다:

// 정렬할 배열
let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]

// 일반 함수를 사용한 정렬
func backward(_ s1: String, _ s2: String) -> Bool {
    return s1 > s2
}
var reversedNames = names.sorted(by: backward)
// ["Ewa", "Daniella", "Chris", "Barry", "Alex"]

// 클로저 표현식을 사용한 정렬
reversedNames = names.sorted(by: { (s1: String, s2: String) -> Bool in
    return s1 > s2
})

sorted(by:): 배열의 요소를 정렬하는 메서드로, 정렬 기준을 정의하는 클로저를 인자로 받습니다.

📌 클로저 최적화 기법

Swift는 클로저 코드를 더 간결하게 작성할 수 있는 여러 최적화 기법을 제공합니다:

1. 타입 추론

컨텍스트에서 타입을 유추할 수 있을 때는 타입 명시를 생략할 수 있습니다:

reversedNames = names.sorted(by: { s1, s2 in return s1 > s2 })

타입 추론(Type Inference): Swift가 코드의 컨텍스트를 기반으로 변수나 상수의 타입을 자동으로 결정하는 기능

2. 단일 표현식의 암시적 반환

클로저가 단일 표현식만 포함하는 경우 return 키워드를 생략할 수 있습니다:

reversedNames = names.sorted(by: { s1, s2 in s1 > s2 })

3. 축약 인수 이름

인라인 클로저에서는 $0, $1, $2 등과 같은 축약 인수 이름을 사용할 수 있습니다:

reversedNames = names.sorted(by: { $0 > $1 })

축약 인수 이름(Shorthand Argument Names): 클로저에서 자동으로 제공되는 $0, $1 등의 파라미터 이름으로, 각각 첫 번째, 두 번째 인자를 나타냅니다.

4. 연산자 메서드

비교 연산자는 그 자체로 (String, String) -> Bool 타입의 함수이므로 직접 사용할 수 있습니다:

reversedNames = names.sorted(by: >)

📌 후행 클로저 (Trailing Closures)

함수의 마지막 인자가 클로저일 때, 함수 호출 괄호 뒤에 클로저를 작성하는 문법입니다:

// 후행 클로저 구문
reversedNames = names.sorted() { $0 > $1 }

// 클로저가 유일한 인자라면 괄호도 생략 가능
reversedNames = names.sorted { $0 > $1 }

후행 클로저(Trailing Closure): 함수 호출 시 마지막 인자가 클로저인 경우, 괄호 밖에 클로저를 작성할 수 있는 문법

후행 클로저는 클로저가 길거나 복잡할 때 특히 유용합니다:

let numbers = [16, 58, 510]

let strings = numbers.map { (number) -> String in
    var number = number
    var output = ""
    // 복잡한 변환 로직...
    return output
}

여러 클로저가 있는 함수의 경우:

func loadPicture(from server: Server, 
                 completion: (Picture) -> Void, 
                 onFailure: () -> Void) {
    // 함수 구현...
}

// 여러 후행 클로저 사용
loadPicture(from: someServer) { picture in
    someView.currentPicture = picture
} onFailure: {
    print("사진을 다운로드할 수 없습니다.")
}

📌 값 캡처 (Capturing Values)

클로저는 정의된 컨텍스트의 상수와 변수를 캡처하여 나중에 사용할 수 있습니다. 이것은 클로저가 생성된 환경의 값을 "기억"할 수 있게 해줍니다:

func makeIncrementer(forIncrement amount: Int) -> () -> Int {
    var runningTotal = 0
    func incrementer() -> Int {
        runningTotal += amount
        return runningTotal
    }
    return incrementer
}

let incrementByTen = makeIncrementer(forIncrement: 10)
incrementByTen() // 10
incrementByTen() // 20
incrementByTen() // 30

값 캡처(Capturing Values): 클로저가 자신이 정의된 환경의 변수나 상수를 참조하여 저장하는 것

이 예제에서 incrementer 함수는 runningTotal과 amount 변수를 캡처하여, makeIncrementer 함수가 반환된 후에도 이 값들을 기억하고 사용할 수 있습니다.

📌 클로저는 참조 타입 (Closures Are Reference Types)

함수와 클로저는 참조 타입입니다. 즉, 클로저를 변수나 상수에 할당할 때 실제로는 클로저에 대한 참조가 할당됩니다:

let alsoIncrementByTen = incrementByTen
alsoIncrementByTen() // 40
incrementByTen()     // 50

참조 타입(Reference Type): 인스턴스가 복사되는 대신 참조로 전달되는 타입. 같은 클로저를 참조하는 여러 변수는 같은 클로저 인스턴스를 가리킵니다.

📌 탈출 클로저 (Escaping Closures)

클로저가 함수의 인자로 전달되었지만 함수가 반환된 후에도 호출될 수 있다면 이를 "탈출 클로저"라고 합니다:

var completionHandlers: [() -> Void] = []

func someFunctionWithEscapingClosure(completionHandler: @escaping () -> Void) {
    completionHandlers.append(completionHandler)
}

탈출 클로저(@escaping): 함수가 반환된 후에도 실행될 수 있는 클로저. 함수 외부 변수에 저장되거나 비동기 작업에 사용될 때 흔히 필요합니다.

탈출 클로저에서 self를 참조할 때는 특별한 주의가 필요합니다:

class SomeClass {
    var x = 10
    func doSomething() {
        someFunctionWithEscapingClosure { self.x = 100 }  // self 명시적 사용
        someFunctionWithNonescapingClosure { x = 200 }    // self 암시적 사용 가능
    }
}

Swift 5.3부터는 클로저 캡처 목록을 사용해 self를 캡처할 수도 있습니다:

someFunctionWithEscapingClosure { [self] in x = 100 }

📌 자동 클로저 (Autoclosures)

자동 클로저는 함수에 인자로 전달되는 표현식을 자동으로 클로저로 감싸는 기능입니다:

var customersInLine = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]

// 일반 클로저
func serve(customer customerProvider: () -> String) {
    print("Now serving \(customerProvider())!")
}
serve(customer: { customersInLine.remove(at: 0) })

// 자동 클로저
func serve(customer customerProvider: @autoclosure () -> String) {
    print("Now serving \(customerProvider())!")
}
serve(customer: customersInLine.remove(at: 0))  // 클로저 구문 없이 표현식만 전달

자동 클로저(@autoclosure): 인자로 전달된 표현식을 자동으로 클로저로 래핑하는 속성. 코드를 더 간결하게 만들지만, 남용하면 가독성이 떨어질 수 있습니다.

자동 클로저의 가장 큰 특징은 코드 실행을 지연시킨다는 점입니다. 클로저가 실제로 호출될 때까지 내부 코드는 실행되지 않습니다.

탈출이 필요한 자동 클로저는 @autoclosure와 @escaping 속성을 모두 사용합니다:

func collectCustomerProviders(_ customerProvider: @autoclosure @escaping () -> String) {
    // 구현...
}

---

이상으로 Swift의 클로저에 대한 설명을 마치겠습니다.