Closure

함수처럼 기능을 수행하는 코드블록

함수와 다르게 이름이 없다

/*
{ (parameters) -> return type in
    statement
 ...
 }
 */

// Cho Simple Closure

let ChoSimpleClosure = {
    
}
ChoSimpleClosure()


// 코드 블록을 구현한 Closure

let CodeBlockClosure = {
    print("this is code block")
}
CodeBlockClosure()


// 인풋 파라미터를 받는 Closure

let InputParamClosure: (String) -> Void = { name in
    print("input param is \(name)")
}
InputParamClosure("closure")


// 값을 리턴하는 Closure

let returnClosure: (String) -> String = { name in
    let message = "iOS Developer, \(name)"
    return message
}
let rresult = returnClosure("YOU") // "iOS Developer, YOU"
print(rresult) // "iOS Developer, YOU\n"


// Closure를 파라미터로 받는 함수 구현

func someSimpleFunction(choSimpleClosure: () -> Void) {
    print("func called")
    choSimpleClosure() // 파라미터로 받은 closure 구현
}

someSimpleFunction(choSimpleClosure: {
    print("closure called") // func called // closure called
})


// Trailing Closure
// 마지막 인자가 closure인 경우에 이름 생략 가능

func multiParamsFunction(message: String, soSimpleClosure: () -> Void) {
    print("func called, message is \(message)")
    soSimpleClosure()
}

//multiParamsFunction(message: "", soSimpleClosure: {
//    print("closure called") // func called, message is  // closure called
//})

multiParamsFunction(message: "") {
    print("closure called") // func called, message is  // closure called
}

 

// 일반적인 함수(func)도 closure라고 보면됨.
// 하지만 closure는 보통 "익명 함수"라고 생각하면 됨.
let closure = { (parameters) -> return type in
    statements
}


// Int, Int 를 받아서 Int를 리턴.
var multiplayClosure: (Int, Int) -> Int = { a, b in
    return a * b
}

let result = multiplayClosure(4, 2) // 8

func operateTwoNum(a: Int, b: Int, operation: (Int, Int) -> Int) -> Int {
    let result = operation(a, b)
    return result
}

operateTwoNum(a: 4, b: 2, operation: multiplayClosure) // 8

var addClosure: (Int, Int) -> Int = { a, b in
    return a + b
}

operateTwoNum(a: 4, b: 2, operation: addClosure) // 6

operateTwoNum(a: 4, b: 2) { a, b in
    return a / b // 2
}