ํด๋ก์ (Closure) ๋?
๊ฐ๋จํ๊ฒ ๋งํ๋ฉด ํด๋ก์ ๋ ์ผ์ ๊ธฐ๋ฅ์ ํ๋ ์ฝ๋๋ฅผ { }
๋ก ๋ชจ์๋์๊ฒ์ ๋งํ๋ค. ๊ทธ๋ฆฌ๊ณ ์ผ๋ฐ์ ์ธ func
๋ก ์ ์ธ๋๋ ํจ์์ ์์๊ฐ๋
์ด ํด๋ก์ ์ด๋ค.
์ ํด๋ก์ ๋ผ๊ณ ํ์ง?
ํด๋ก์ ๋ ๋ณ์, ์์๊ฐ ์ ์ธ๋ ์ค์ฝํ์์ ์ฐธ์กฐ๋ฅผ ์บก์ณ(์ ์ฅ) ํ ์ ์๋๋ฐ ์ด๊ฑธ ํด๋ก์ง์ด๋ผ๊ณ ํ๋ฉฐ ๊ทธ๋์ ํด๋ก์ ๋ผ๊ณ ์ด๋ฆ๋ถ์ฌ์ก๋ค.
ํด๋ก์ ๋ฅผ ์ ์ฐ๋?
์ค์ํํธ๋ ํจ์ํ ํ๋ก๊ทธ๋๋ฐ ํจ๋ฌ๋ค์์ด๋ผ๊ณ ํ๋๋ฐ, ์ด๋ฌํ ์คํ์ผ์ ํด๋ก์ ๊ฐ ์ค์ํ ์ญํ ์ ํ๋ค. ํด๋ก์ ๋ฅผ ์ ๋ค๋ฆญ, ํ๋กํ ์ฝ, ๋ชจ๋๋์ ํจ๊ป ์ฌ์ฉํ๋ฉด์ ์ค์ํํธ๋ ๋ ๊ฐ๋ ฅํ ์ธ์ด๊ฐ ๋ ์์๋ค.
ํด๋ก์ ์ ํํ(์ข
๋ฅ)
์ด๋ฆ์ด ์๊ณ , ๊ฐ์ ์บก์ณํ์ง ์๊ณ , ์ ์ญํจ์์ ํํ
์ด๋ฆ์ด ์๊ณ , ๋ค๋ฅธ ํจ์์ ๊ฐ์ ์บก์ณํ๋ ์ค์ฒฉ๋(nested) ํจ์ ํํ
์ด๋ฆ ์๊ณ , ์ฃผ๋ณ context์ ๋ฐ๋ผ์ ๊ฐ์ ์บก์ณํ ์ ์๋ ์ถ์ฝ ํจ์ํํ.
ํด๋ก์ ์ ํํ๋ฐฉ๋ฒ
์์ ํ๊ฒ ๋์น์ธ ์ฝ๋๋ผ๋, ํด๋ก์ ๋ ํํ๋ฐฉ๋ฒ์ด ์ฌ๋ฌ๊ฐ์ง์ด๊ธฐ ๋๋ฌธ์ ์ด๋ ต๊ฒ ๋๊ปด์ง๋๊ฒ๊ฐ๋ค.
parameter์ ํ์
, ๋ฐํ ๊ฐ์ ํ์
์ ์๋ตํ ์ ์๋ค. (swift๋ ํ์
์ถ๋ก ์ด ๊ฐ๋ฅํ๋ฏ๋ก)
ํด๋ก์ ๋ธ๋ญ ์์ ์ฝ๋๊ฐ ํ์ค์ด๋ผ๋ฉด, ์์์ ์ผ๋ก ์ด๋ฅผ ๋ฐํ๊ฐ ์ฒ๋ฆฌํ๋ค.
์ถ์ฝ๋ argument name ์ ์ฌ์ฉํ ์ ์๋ค. ($0... $1... ๋ฑ์ผ๋ก ์ฌ์ฉํ๋๊ฒ)
ํํ ํด๋ก์ (trailing closure) ๋ฌธ๋ฒ์ ์ฌ์ฉํ ์ ์๋ค.
a * b ๋ฅผ ๋ฐํํ๋ ํด๋ก์
์๋ 3๊ฐ์ ํด๋ก์ ๋ ๋ชจ๋ ๊ฐ์ ์ฝ๋์ด๋ค.
var multiply: (Int, Int) -> Int = { (a: Int, b:Int) -> Int in
return a * b
}
/// - ํ๋ผ๋ฏธํฐ(๋งค๊ฐ๋ณ์)์ ํ์
์ญ์ ๊ฐ๋ฅ
var multiply2: (Int, Int) -> Int = { (a, b) -> Int in
return a * b
}
// return ํค์๋ ์ญ์ ๊ฐ๋ฅ + ํ๋ผ๋ฏธํฐ(๋งค๊ฐ๋ณ์) ์ญ์ ๊ฐ๋ฅ
var multiply3: (Int, Int) -> Int = {$0 * $1}
$0, $1 ์ ๊ฐ๊ฐ a,b๋ฅผ ์๋ฏธํ๋ฉฐ ์ด๋ ๊ฒ ํํํ๋ ๊ฒ์ shorhand argument๋ผ๊ณ ํ๋ค.
ํจ์๊ฐ ํด๋ก์ ๋ฅผ argument๋ก ๋ฐ๋์ํฉ - ๋ค์ํ ํ์ฉ์ด ๊ฐ๋ฅ
func operateTwoNum(a: Int, b: Int, operation: (Int, Int) -> Int) -> Int {
let result = operation(a,b)
return result
}
var add: (Int, Int) -> Int = { a,b in
return a + b
}
operateTwoNum(a: 4, b: 9, operation: multiply) // multyply๋ฅผ ๋ฃ์ผ๋ฉด ๊ณฑํ๊ธฐ
operateTwoNum(a: 4, b: 9, operation: add) // add ํด๋ก์ ๋ฅผ ๋ฃ์ด ๋ํ๊ธฐ
operateTwoNum(a: 4, b: 9 ){ a, b in // ์๊ท๋จผํธ ๋ธ๋ญ์ ํด๋ก์ ๋ฅผ ์ง์ ๊ตฌํํด๋ ๋๋ค.
return a - b
}
typealias์ ๊ฐ์ด ์ฌ์ฉํ๋ ํด๋ก์
let c = {(str:String)->String in
return "Hello \(str)"
}
typealias MyType = (String) -> String
func perform(closure: MyType){
print(closure("iOS"))
}
perform(closure: c) // closure์ c๋ฅผ ์ ๋ฌ
fucking closure syntax
Url์ ํ๋์์ง๋ง ๊ฐ๋ณด๋ฉด ๋ค์ํ ํด๋ก์ ํํ๊ฐ ๋์จ๋ค.
https://fuckingclosuresyntax.com/
How Do I Declare a Closure in Swift?
As a variable: var closureName: (ParameterTypes) -> ReturnType = { ... } As an optional variable: var closureName: ((ParameterTypes) -> ReturnType)? As a type alias: typealias ClosureType = (ParameterTypes) -> ReturnType As a constant: let closureName: Clo
fuckingclosuresyntax.com
์ฐธ๊ณ ์๋ฃ
https://docs.swift.org/swift-book/LanguageGuide/Closures.html#ID103