[Swift] 클로저

 

💡 클로저

 

1. 이름이 없는 함수

2. 일정 기능을 하는 코드를 하나의 블록으로 모아놓은 것

 

코드를 유용하게 작성하기 위해 사용한다.

 

클로저 표현 방법

클로저가 함수의 모습이 아닌 하나의 블록 모습으로 표현될 수 있는 방법

 { (매개변수들) -> 반환타입 in

    실행코드

 }

 

** in이라는 키워드는 정의부와 실행부를 분리하기 위해서 사용한다

 

---

함수와 클로저 비교

** 함수는 클로저의 한 형태이다

 

let names: [String] = ["Bonny", "John", "Ham"]


// 배열 값을 정렬하는 sorted(by: ) 메서드를 통해 함수와 클로저 비교해보기
// 함수
func backwards(first: String, second: String) -> Bool {
    return first > second   //true일 경우 first 반환
}

let reversed1: [String] = names.sorted(by: backwards(first:second:))
print(reversed1)

// 클로저
let reversed2: [String] = names.sorted(by: { (first: String, second: String) -> Bool in
    return first > second
})

print(reversed2)

 

---

클로저 표현 간소화

 

// 1. 문맥을 이용한 타입 유추(자료형 생략)
let SimpleClosure1: [String] = names.sorted(by: { (first, second) -> Bool in
    return first > second
})

// 2. 단축 인자 이름($0, $1, ...)
let SimpleClosure2: [String] = names.sorted {
    return $0 > $1
}

// 3. 암시적 반환 표현(return 생략)
let SimpleClosure3: [String] = names.sorted { $0 > $1 }

// 4. 연산자만 표기하기(매개변수 타입과 반환 타입이 연산자를 구현한 함수 모양과 동일한 경우)
let SimpleClosure4: [String] = names.sorted (by: >)

 

---

클로저 값 획득

- 자신이 정의된 위치의 주변 문맥을 통해 상수나 변수를 획득할 수 있다

 

- 클로저는 비동기 작업에 많이 사용되는데, 클로저를 통해 비동기 콜백을 작성하는 경우 현재 상태를 미리 획득해두지 않으면 클로저의 기능을 실행하는 순간 주변의 상수나 변수가 메모리에 존재하지 않는 경우가 발생할 수 있다

 

func makeIncrementer(forIncrement amount: Int) -> (() -> Int) {
    var runningTotal = 0
    
    // 중첩 함수 incrementer()는 자신 주변에서 runningTotal과 amount 값을 획득한다
    // 두 값을 획득한 후 클로저로서 makeIncrementer()에 의해 반환된다
    func incrementer() -> Int {
        runningTotal += amount
        return runningTotal
    }
    return incrementer
}

// () -> Int 는 함수 객체를 반환한다는 의미이다 매개변수를 받지 않고 반환 타입은 Int인 함수이다
// forIncrement는 전달인자 레이블

// runningTotal과 amount값은 makeIncrementer() 함수 실행이 끝나도 사라지지 않는다
// => 함수를 호출할 때마다 두 개의 값이 누적된다

let incrementByTwo: (()->Int) = makeIncrementer(forIncrement: 2)
// 함수와 클로저는 참조 타입이기 때문에 변수에 할당할 때마다 사실은 상수나 변수에 함수나 클로저의 참조를 설정하는 것이다

let first: Int = incrementByTwo()
print(first)    //2

let second: Int = incrementByTwo()
print(second)   //4

let third: Int = incrementByTwo()
print(third)    //6

// 새롭게 선언될 때마다 초기화되지 않고 이전에 캡쳐한 값으로 계속해서 사용한다!

 

---

탈출 클로저

함수의 전달인자로 전달한 클로저가 함수 종료 후에 호출될 때 클로저가 함수를 탈출한다고 표현한다

클로저를 매개변수로 갖는 함수 선언시 매개변수 이름의 콜론 뒤에 @escaping 키워드 사용

 

클로저가 함수를 탈출할 수 있는 경우

• 함수 외부에 정의된 변수나 상수에 저장되어 함수가 종료된 후에 사용할 경우
• 함수의 전달인자로 전달받은 클로저를 다시 반환할 경우

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

 

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

//탈출 클로저를 매개변수로 갖는 함수


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


typealias VoidClosure = () -> Void

let firstClosure: VoidClosure = {
    print("Closure A")
}

let secondClosure: VoidClosure = {
    print("Closure B")
}

// 전달인자로 전달받은 클로저를 함수 외부로 다시 반환 -> 함수 탈출
func returnOneClosure(first: @escaping VoidClosure, second: @escaping VoidClosure,
                      shouldReturnFirstClosure: Bool) -> VoidClosure {
    return shouldReturnFirstClosure ? first : second
}

// 함수 외부로 반환한 클로저를 함수 외부의 상수에 저장
let returnedClosure: VoidClosure = returnOneClosure(first: firstClosure, second: secondClosure, shouldReturnFirstClosure: true)

returnedClosure()   //Closure A

var closures: [VoidClosure] = []

func appendClosure(closure: @escaping VoidClosure) {
    closures.append(closure)
}

 

---

withoutActuallyEscaping

실제로는 탈출하지 않는데 다른 함수에서 탈출 클로저를 요구하는 상황

withoutActuallyEscaping(_ : do: )

 

let numbers: [Int] = [2, 4, 6, 8]

let evenNum = { (number: Int) -> Bool in
    return number % 2 == 0
}

let oddNum = { (number: Int) -> Bool in
    return number % 2 == 1
}


// hasElements(in: 매개변수로 검사할 배열 match: 매개변수로 검사를 실행할 클로저를 받아들임

func hasElements(in array: [Int], match predicate: (Int) -> Bool) -> Bool {
    return withoutActuallyEscaping(predicate, do: { escapablePredicate in
        return (array.lazy.filter { escapablePredicate($0) }.isEmpty == false)
    })
}

let hasEvenNum = hasElements(in: numbers, match: evenNum)
let hasOddNum = hasElements(in: numbers, match: oddNum)

print(hasEvenNum)   //true
print(hasOddNum)    //false

 

---

자동 클로저

함수의 전달인자로 전달할 표현을 자동으로 변환해주는 클로저이다

 

• 자동 클로저는 전달인자를 갖지 않는다
• 호출되었을 때 자신이 감싸고 있는 코드의 결괏값을 반환한다

var customer: [String] =  ["Bonny", "yeonsu", "Jhon"]

func serveCustomer(_ customerProvider: @autoclosure () -> String) {
    print("Now serving \(customerProvider())!")
}

serveCustomer(customer.removeFirst())   //Now serving Bonny!