[Swift] Closure에 대해 알아봅시다.

오늘은 그동안 많이 쓰였지만 그냥 지나친 closure에 대해 알아보고자 한다.

 

생략된 표현이 많아서 이게 함수인가? 하고 의문이 들때도 많고 swift/IOS 초보 일때는 많이 헷갈리는 개념인거 같다.

공식 문서(swift-closure)와 함께 정리하다보면 이제 유용하게 잘 쓰겠지 !! 

 

Closure란?

익명 함수 func으로 선언하는 것이 아닌 함수를 변수에 선언하는 형태

공식 문서에는 

클로저는 어떤 상수나 변수의 참조를 캡쳐(capture)해 저장할 수 있다. 라고 정의해두었다. 이에 대해 아래에서 자세하게 살펴보자

 

클로저가 가지는 형태는 다음과 같이 3가지다

 

전역 함수 : 이름 O, 캡쳐 X

중첩 함수 : 이름 O, 캡쳐 O

클로저 표현 : 이름 X, 경량화된 문법으로 관련된 문맥(Context)로부터 값을 캡쳐 O

 

클로저 표현은 간결함을 추구한다! (그래서 알아보기 어려운 거였군)

최적화를 추구하는데 아래와 같은 부분에 있어서 함축을 추구한다

 

 

• 문맥(context)에서 인자 타입(parameter type)과 반환 타입(return type)의 추론
• 단일 표현 클로저에서의 암시적 반환
• 축약된 인자 이름
• 후위 클로저 문법

정렬 메소드(Sorted Method)

swift 표준 라이브러리 sorted(by:)의 by부분에 어떤식으로 정렬할 건지 기술한 클로저를 넣으면 그 방법대로 정렬된 배열을 얻을 수 있다. 예시로 살펴보자

let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]

 

 

클로저를 넣는 일반적인 방법은 하나의 함수를 만들어 넣는것이다.

func backward(_ s1: String, _ s2: String) -> Bool {
    return s1 > s2
}
var reversedNames = names.sorted(by: backward)
// reversedNames is equal to ["Ewa", "Daniella", "Chris", "Barry", "Alex"]

backward 함수를 만들고 sorted(by:) 부분에 변수처럼 backward 함수를 넣어 주었다. 

 

다양한 클로저들에 대해서도 알아보기 위해 클로저의 표현 문법에 대해 살펴보도록 하자

{ (parameters) -> return type in
    statements
}

 

이것이 클로저의 표현 문법이다!!

parameter(인자)에 대해 처리할 부분은  in 뒤에 있는 statement에 넣어주고 statement에서 처리를 끝낸 뒤 return하는 타입을 명시해준다. 이렇게 함수로 따로 정의된 형태가 아닌 인자로 들어가 있는 형태의 클로저를 인라인 클로저라 부른다.

 

앞의 backward함수는 다음과 같이 쓰일 수도 있다.

 

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

 

문맥에서 타입 추론

여기서부터 기본형에 대한 축약이 일어난다. 긴장해야 한다!

만약 sorted(by:)에서 이미 (String, String) -> Bool 타입의 인자가 들어와야 하는지 안다면 클로저에서 이 타입들은 생략 될 수 있다. 

 

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

parameter와 return의 타입이 생략된걸 확인 할 수 있다.

 

단일 표현 클로저에서의 암시적 반환

말에서 알 수 있듯이 이번에는 반환 keword가 생략 될 것이다. return의 위치가 정해져 있으므로 생략해도 전혀 모호해지지 않기 때문이다. 

 

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

 

이름 인자 축약

이번에는 인자 이름을 축약해볼 것이다.. 생략까진 아니고 이름만 간결한 이름으로 표현하는 것이다.

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

$ 표현과 함께 숫자로 표현했다. 제법 많은게 생략되어서 더 줄일 수 없을 거라 생각할 것이다.

 

하지만 한번 더 있다 하하 

 

연산자 메소드

reversedNames = names.sorted(by: >)

두둥 .. ㄷ ㄷ ㄷ 

나같이 생각이 많은 사람들은 다양한 해석을 할 수도 있을 것 같다는 생각이 든다. 너무 많은 축약과 생략은 협업과 코드 리뷰에 안 좋을 수도 좋을 수도 있으니 무작정 남발적으로 사용해선 안된다

 

---

 

후위 클로저 Trailing Closures

만약 함수의 마지막 인자로 클로저를 넣고 그 클로저가 길다면 후위 클로저를 사용할 수 있다. 

예시로 살펴보자

func someFunctionThatTakesAClosure(closure: () -> Void) {
    // function body goes here
}

 

만약 이런 형태의 클로저가 있다면 클로저의 인자 값 입력 부분 ( () ) 과 반환형 부분 ( -> 뒷부분)을 생략해서 

 

someFunctionThatTakesAClosure(closure: {
    // closure's body goes here
})

또는 

someFunctionThatTakesAClosure() { }

 이렇게 쓸 수 있다. 

 

우와 이것도 클로저였구나 ..!!! 대박 대박

 

다른 예제도 살펴보자

let digitNames = [
    0: "Zero", 1: "One", 2: "Two",   3: "Three", 4: "Four",
    5: "Five", 6: "Six", 7: "Seven", 8: "Eight", 9: "Nine"
]

let numbers = [16, 58, 510]

let strings = numbers.map { (number) -> String in
    var number = number
    var output = ""
    repeat {
        output = digitNames[number % 10]! + output
        number /= 10
    } while number > 0
    return output
}
// let strings는 타입 추론에 의해 문자 배열([String])타입을 갖습니다.
// 결과는 숫자가 문자로 바뀐 ["OneSix", "FiveEight", "FiveOneZero"]가 됩니다.

map 함수를 사용해 각 자리수를 구해서 문자로 변환하고 10으로 나눈 뒤 자리수를 바꿔 문자로 변환하는 것을 반복한다. number는 상수인데 클로저 안에서 var로 재정의했기 때문에 값이 변환 가능하다.

 

 

 

값 캡쳐  Capturing Values

클로저는 특정 문맥의 상수나 변수의 값을 캡쳐할 수 있다. 

다시말해 원본 값이 사라져도 클로져의 body안에서 그 값을 활용할 수 있다는 것.

Swift에서 값을 캡쳐 하는 가장 단순한 형태는 중첩 함수(nested function) 를 사용하는 것인데 예제로 살펴보자

 

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

makeIncrementer 함수 안 incrementer 함수가 중첩된 구조다. 이때 클로저가 조금 신기하게 생겼다.

 

(forIncrement amount: Int) -> () -> Int 중에 처음 -> 를 기준으로 앞의 (forIncrement amount: Int) 부분이 인자 값이고 뒤 () -> Int는 반환 값입니다. --> (forIncrement amount: Int) ->  //////  () -> Int 이렇게 끊어 읽어야 한다. 즉 반환 값 부분이 클로저다!!

 

func incrementer() -> Int {
    runningTotal += amount
    return runningTotal
}

 

incrementer 함수만을 보면 runningTotal와 amount가 캡쳐링 되었다고 표현한다.

makeIncrementer 함수 실행 시 () -> Int 클로저를 반환하는데 이에 대해 incrementer함수가 실행되고 그에 대한 메소드를 반환한다.

 

클로저는 참조타입이므로 함수와 클로저를 상수나 변수에 할당할 때 실제로는 상수와 변수에 해당 함수나 클로저의 참조(reference)가 할당된다. 그래서 만약 한 클로저를 두 상수나 변수에 할당하면 그 두 상수나 변수는 같은 클로저를 참조하게 된다. 함수 포인터를 저장한다고 생각하시면 이해하기 쉬우실 것!! 

 

---

이스케이핑 클로저 Escaping Closures

 

클로저를 함수의 파라미터로 넣을 수 있는데, 함수 밖(함수가 끝나고)에서 실행되는 클로저 예를들어, 비동기로 실행되거나 completionHandler로 사용되는 클로저는 파라미터 타입 앞에 @escaping이라는 키워드를 명시해야 한다.

 

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

func someFunctionWithEscapingClosure(completionHandler: @escaping () -> Void) {

completionHandlers.append(completionHandler)

}

위 함수에서 인자로 전달된 completionHandler는 someFunctionWithEscapingClosure 함수가 끝나고 나중에 처리 된다. 만약 함수가 끝나고 실행되는 클로저에 @escaping 키워드를 붙이지 않으면 컴파일시 오류가 발생합니다.

@escaping 를 사용하는 클로저에서는 self를 명시적으로 언급해야 합니다.

 

func someFunctionWithNonescapingClosure(closure: () -> Void) {

closure() // 함수 안에서 끝나는 클로저

}



class SomeClass {

var x = 10

func doSomething() {

someFunctionWithEscapingClosure { self.x = 100 } // 명시적으로 self를 적어줘야 합니다.

someFunctionWithNonescapingClosure { x = 200 }

}

}



let instance = SomeClass()

instance.doSomething()

print(instance.x)

// Prints "200"



completionHandlers.first?()

print(instance.x)

// Prints "100"

 

---

 

자동클로저 Autoclosures

 

자동클로저는 인자 값이 없으며 특정 표현을 감싸서 다른 함수에 전달 인자로 사용할 수 있는 클로저입니다. 자동클로저는 클로저를 실행하기 전까지 실제 실행이 되지 않습니다. 그래서 계산이 복잡한 연산을 하는데 유용합니다. 왜냐면 실제 계산이 필요할 때 호출되기 때문입니다. 예제를 보면서 무슨 뜻인지 알아 보겠습니다.

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

print(customersInLine.count)

// Prints "5"



let customerProvider = { customersInLine.remove(at: 0) }

print(customersInLine.count)

// Prints "5"



print("Now serving \(customerProvider())!")

// Prints "Now serving Chris!"

print(customersInLine.count)

// Prints "4"

위 예제 코드를 보면 let customerProvider = { customersInLine.remove(at: 0) } 이 클로저 코드를 지났음에도 불구하고 customersInLine.count 는 변함없이 5이다.

그리고 그 클로저를 실행시킨 print("Now serving \(customerProvider())!") 이후에야 배열에서 값이 하나 제거되어 배열의 원소 개수가 4로 줄어든다. 이렇듯 자동 클로저는 적혀진 라인 순서대로 바로 실행되지 않고, 실제 사용될 때 지연 호출 되는 방식이다.

자동클로저를 함수의 인자 값으로 넣는 예제는 아래와 같습니다.

 

// customersInLine is ["Alex", "Ewa", "Barry", "Daniella"]

func serve(customer customerProvider: () -> String) {

print("Now serving \(customerProvider())!")

}

serve(customer: { customersInLine.remove(at: 0) } )

// Prints "Now serving Alex!"

serve함수는 인자로 () -> String) 형, 즉 인자가 없고, String을 반환하는 클로저를 받는다.

 

위 예제를 @autoclosure키워드를 이용해서 보다 간결하게 사용할 수 있을 것이다.

아래 예제를 살펴보자

// customersInLine is ["Ewa", "Barry", "Daniella"]

func serve(customer customerProvider: @autoclosure () -> String) {

print("Now serving \(customerProvider())!")

}

serve(customer: customersInLine.remove(at: 0))

// Prints "Now serving Ewa!"

 이 키워드를 붙임으로써 인자 값은 자동으로 클로저로 변환된다. 함수의 인자 값을 넣을 때 클로저가 아니라 클로저가 반환하는 반환 값과 일치하는 형의 함수를 인자로 넣을 수 있다. 그래서 serve(customer: { customersInLine.remove(at: 0) } ) 이런 코드를 @autoclosure키워드를 사용했기 때문에 serve(customer: customersInLine.remove(at: 0)) 이렇게 {} 없이 사용할 수 있는 것이다.

정리하면 클로저 인자에 @autoclosure를 선언하면 함수가 이미 클로저 인것을 알기 때문에 리턴값 타입과 같은 값을 넣어줄 수 있습니다.

 

클로저는 축약하려는 특징 때문에 다양한 표현들을 가지는 것처럼 보인다. 하나 하나 단계적으론 생략되어 코드를 보아야 하지만 이 단계를 알고 있다면 클로저임을 파악하고 무슨 의미를 나타내는 것인지 파악할 수 있을 것이다!

 

이제 정리 했으니까 closure랑 많이 친해지도록 👏👏