히파루스의 솔직한 여행 이야기

본 포스팅은 남 포스팅을 공부하며 정리한 내용이다.
원본 강좌 포스팅은 아래를 참고
(https://www.boostcourse.org/mo122/lecture/11297?isDesc=false)

클로저를 포함해 요즘것들은 뭐가 그리 잘났다고 줄여대는지 도덕책 근본이 없다.
개발은 평생 지 혼자 싸들고 하나
남 생각도 할 줄 알아야 그기 사람 아이가 그기 마!

클로저는 다양하게 표시할 수 있는데 일단 클로저를 받아줄 함수를 선언하자
Int형의 인자 a, b 2개를 받고 클로저를 받을 method마찬가지로 Int형 2개와 리턴형은 당연히 Int다
콩에는 콩 팥에는 팥이다.

func calc(a:Int, b:Int, method:(Int, Int)-> Int) -> Int{
    return method(a, b)
}

후행클로저
위 calc라는 함수의 마지막 파라메터가 클로저가 함수의 마지막 인자일 때 가능하며, 마지막 파라메터의 이름을 생략할 수 있다.
이렇게
result = calc(a:10, b:10) {(left:Int, right:Int) -> Int in
    return left + right
}

반환타입 생략
상식적으로다가 파라메터가 Int가 넘어왔으면 Int를 리턴해준다라는것 정도는 컴파일러가 알기 때문에 리턴 타입인 -> Int는 생략해도 되겠다.
다만 in은 삭제 불가

이렇게 호출해야 하는걸
result = calculate(a: 10, b: 10, method: { (left: Int, right: Int) -> Int in
    return left + right
})

method를 날려줄 수 있고
result = calculate(a: 10, b: 10), method: { (left: Int, right: Int) -> Int in
    return left + right
}

-> Int도 날려줄 수 있다.
result = calc(a:10, b:10) {(left:Int, right:Int) -> Int in
    return left + right
}

최종 결과물은 이러하다.
retult = calc(a:10, b:10) {(left:Int, right:Int) in   
    return left + right
}

위에 단축한 결과와
아래 원래 
result = calc(a: 10, b: 10, method: { (left: Int, right: Int) -> Int in
    return left + right
})

단축 인자 이름
result = calc(a: 10, b: 10, method: { (left: Int, right: Int) -> Int in
    return left + right
})

result = calc(a: 10, b: 10) {
    return $0 + $1
}

암시적 반환
한줄로도 표현이 가능한데...
클로저가 반환값이 있다면 클로저의 마지막 줄 결과값을 암시적으로 반환값으로 치부하여 return 없이도 return
뭔 홍길동 호부호형도 아니고 리턴을 왜 리턴이라 하지 못하는지.
깔끔은 하지만 좀 그렇다.
result = calc(a: 10, b: 10) { $0 + $1 }

클로저 공부 중 정리와 암기를 위한 타이핑용 포스팅이며 원본은 야곰이란 분의 포스팅을 보는걸 추천함
(https://www.boostcourse.org/mo122/lecture/11296)
컴파일러 없이 웹상에서 간단하게 playground 환경으로 테스트 하기 위한 경우 아래 링크에서 swift 문법 테스트가 가능함
https://www.onlinegdb.com/online_swift_compiler

클로저란?
실행가능한 코드 블럭
일급객체로 변수, 상수, 전달인자 등에 저장은 물론 전달이 가능
클로저는 이름이 있는 클로저와 이름이 없는 클로저로 존재
함수도 클로저의 일종으로 이름이 클로저임
함수와 다르게 이름 정의는 필요하지 않고, 매개변수 전달과 반환 값이 존재 할 수 있다란 점은 동일함

클로저 기본 문법
{(매개변수 목록) -> 반환타입 in
    실행코드
}

클로저 기본 사용 방법
var든 let이든 상관없이 선언 후 선언된 변수나 상수에 클로저를 할당하면 됨
var printName:(String, String)->String = {(firstName:String, lastName:String) in
    return firstName + lastName
}
1. var printName printName이란 변수를 선언
2. (String, String)->String String형태로 인자 2개를 받고 이를 String형태로 리턴해준다란 의미
3. firstName:String, lastName:String 인자 이름은 첫번째가 firstName, 두번째가 lastName
4. 실행코드의 구분은 in 전후로 나뉘고 실행코드는 return firstName + lastName 이므로
    넘겨받은 첫번째, 마지막 이름을 연결해서 리턴해줌

함수의 전달인자인 클로저
클로저는 주로 함수의 전달인자로 많이 사용된다 함.
함수 내부에서 코드블럭을 실행 할 수도 있다 함.
그런데 뭔말인지 모르겠음. 쉽게 생각해보면 작고 귀엽고 간단한 클로저를 하나 먼저 만들고
이 귀염뽀찍 클로저를 다른 함수에 전달해서 함수에서 호출하고 지지고 볶는 그런 느낌인가 봄
먼저 4칙연산 중 덧셈 클로저를 만들어보겠음
let add: (int, int) -> int
뭔가 이상하지 않음?
int의 i가 대문자여야 함 다시 작성하겠음(이러면서 문법과 친해지는거임)
let add: (Int, Int) -> Int
add = { (a: Int, b: Int) in
    return a + b
}

위처럼 작성해도 되고 아래처럼 작성해도 됨

let add2: (Int, Int) -> Int = {(a: Int, b: Int) in
    return a + b
}

아직까진 swift가 지멋대로 축약질에 변동성이 너무 강해 짜증이 남.
요즘 언어들은 싸가지들이 없음.
근본이 없음. 지들만 잘난냥 떠들어재끼는 MZ들처럼

함수를 만들어줌
a,b를 인자로 Int형을 받고 아까 말했듯이 클로저를 함수에 전달할 수 있으니 이부분을 method라는 이름으로 구현해줌
func calc(a:Int, b:Int, method:(Int, Int)->Int)->Int {
    return method(a, b)
}
조금 분해해서 살펴보면
함수니까 func라고 쓰고 함수이름 아무거나정해서 calc라고 적었음
함수니까 괄호열어주고 (
전달받는 인자는 2개 그다음이 클로저인데 앞서 add클로저를 보면 let add: (Int, Int) -> Int 임
여기에서 let add: (Int, Int) -> Int 앞에 let add어쩌구는 제끼고 그 뒤엣것만 가지고 온거임
함수니까 괄호닫아주고 )
그리고 리턴형이 Int니까 -> Int 써준게 전부
그 다음은 함수 실행부이니 전달받은 클로저를 전달한 인자 a,b로 그냥 실행 method(a, b)

함수까지 만들었으니 이제 실행하면 됨.
먼저 Int형 변수 하나 선언해주고
var nCalcResult:Int

이 변수에 아까 만든 calc라는 함수를 불러와 넣어줌
이때 method는 클로저인 add 클로저를 호출하면 됨
nCalcResult = calc(a:1, b:1, method:add)

그럼 결과는 
print(nCalcResult) 
2

당연하겠지만 아까 조금 다르게 만든 클로저인 add2를 호출해도 결과는 동일하게 2로 잘 나옴
nCalcResult = calc(a:1, b:1, method:add2)
print(nCalcResult)

덧셈을 해봤으니 이제 뺄셈 나눗셈 곱셈 등을 동일한 방식으로 구현해보면 됨
let substract:(Int, Int) -> Int = {(a:Int, b:Int) in 
    return a - b
}
이렇게 하면 되고
처음에서처럼 아래처럼 하면 됨
let substract:(Int, Int) -> Int
substract = {(a:Int, b:Int) in
    return a - b
}

여전히 익숙하지 않은자를 위해 클로저 문법 안 까먹고 익히는 비법 공유함.
똑같이 반복해서 구간 구간을 점차 완성시키는 방식으로 스스로 타이핑 해보길 강권함.
let 
let substract
let substract:() -> 
let substract:(Int, Int) -> Int
여기까지가 1절 완성임

substract = {
}
substract = {()
}
substract = {(a:Int, b:Int)
}
substract = {(a:Int, b:Int) in
    return a - b
}

최종
let substract:(Int, Int)->Int
substract = {(a:Int, b:Int) in
    return a - b
}

이거 따라했으면 절대 안 까먹음
응용 복습하는 생각으로 나눗셈 만들기 스타또
let divide:(Int, Int) -> Int
divide = {(a:Int, b:Int) in
    return a / b
}

정말 마지막으로 곱셈
let multiple:(Int, Int) -> Int
multiple = {(a:Int, b:Int) in
    return a * b
}

이쯤되면 아까 함수 만드는거 까먹었을 거
func calc(a:Int, b:Int, method:(Int, Int) -> Int) -> Int {
    return method(a, b)
}

var nCalcResult: Int
nCalcResult = calc(a:10, b:2, method:divide)
print(nCalcResult)

곁다리로
클로저 표현을 let add:(Int, Int) -> Int = {(Int:a, Int:b) in 대신에 Int를 빼고 이렇게도 가능함
let add:(Int, Int) -> Int = {(a, b) in
    return a + b
}

import UIKit

var nVal:Int?

nVal = 83

var str:String?

str = String(nVal!)

var str2:String?

str2 = "83"

print(str!)

if str == str2 {

    print("같음")

} else {

    print("다름")

}

String함수에 들어가는 Int형 변수뒤에 !를 안해주면 이렇게 에러 발생