fun sum(a: Int, b: Int): Int{//์ต์์ ํจ์
return a + b
}
=>
fun sum(a: Int, b: Int): a + b
์ด๋ ๊ฒ ์ค์ฌ์ ์ธ ์ ์์
์ด๊ธฐ๊ฐ์ ํจ์์ ๋ฏธ๋ฆฌ ์ฃผ๋ฉด, ์ธ์๋ก ์ ๋ฌ ์๋ฐ์์ ๋ ์ฌ์ฉ!
์ธ์๋ก ๋ค๋ฅธ ๊ฐ์ฃผ๋ฉด ์ด๊ธฐ๊ฐ ๋ฌด์!
vararg
๐จ์์ : ํ๊ท ๊ตฌํ๊ธฐ
๋ชฉํ: ํ๋ ์ด์์ ์ค์๋ฅผ ๋ฐ์์ ๋ชจ๋ ์ค์์ ํฉ์ ํ๊ท ์ ๊ตฌํ๊ณ ์ถ๋ ฅ ํ๋ ค๊ณ ํฉ๋๋ค.
๋ค์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ํจ์๋ฅผ ๊ตฌํํด ๋ณด์ธ์!
์ด๊ธฐ๊ฐ์ ์ํ ์ธ์๋ Floatํ
์ด๊ธฐ๊ฐ์ ๋๋ฒ์งธ ๋ถํฐ ๋์ด๋ ์ธ์์ ์ต์ข
ํ๊ท ๊ฒฐ๊ณผ์ ๋ํจ
์ด๊ธฐ๊ฐ์ ์๋ฌด๋ฐ ์ธ์๋ฅผ ์
๋ ฅํ์ง ์์ผ๋ฉด 0์ ๊ธฐ๋ณธ ์ฌ์ฉ
๋๋ฒ์งธ๋ถํฐ ๋ฐ์๋ค์ผ ์ธ์๋ ๊ฐ๋ณํ ์ธ์๋ก ๋ชจ๋ ์ค์ํ Float
๋ฐํ๊ฐ์ ๋ชจ๋ ์ธ์์ ํ๊ท ๊ฐ์ผ๋ก ๋ง์ฐฌ๊ฐ์ง๋ก ์ค์ํ Double
1) ์์ํจ์ Pure Function
-๋ถ์์ฉ์ด ์๋ ํจ์: ์
๋ ฅ์ด ๋๊ฐ์ผ๋ฉด ์ถ๋ ฅ๋ ๋๊ฐ๋ค!
(๋ถ์์ฉ์ด ์๋ ํจ์: ์
๋ ฅ์ด ๋๊ฐ์๋ ์ถ๋ ฅ์ด ๋ฌ๋ผ์ ์์ธก ๋ถ๊ฐ๋ฅํจ)
-๊ฐ์ด ์์ธก ๊ฐ๋ฅํด ๊ฒฐ์ ์ (deterministic)์ด๋ค.
fun sum (a: Int, b: Int): Int {
return a+b
}
๋ง์ผ a=2, b=1์ด๋ฉด ์๋ฌด๋ฆฌ ๋ฐ๋ณตํด๋ ๊ฒฐ๊ณผ๊ฐ์ด 3์ => ์์ํจ์
-> ์ฌ์ฌ์ฉ์ฑ์ด ๋๊ณ , ๋ณํ ์์
์ ์์ ํ๋ค
-> ํจ์๋ฅผ ๋ณ์๋ ๋ฐ์ดํฐ ๊ตฌ์กฐ์ ์ ์ฅํ ์ ์๋ค!!
=> ์ฝํ๋ฆฐ์์ ํจ์๋ 1๊ธ ๊ฐ์ฒด๋ก ๋ค๋ฃฌ๋ค (1๊ธ ํจ์๋ผ๊ณ ๋ ํ๋ค)
val abc = <ํจ์> // ๊ฐ๋ฅ!
2) ๋๋ค์์ด๋?
-์ต๋ช
ํจ์์ ํ๋๋ก, ์ด๋ฆ ์์ด ์ฌ์ฉ, ์คํ ๊ฐ๋ฅ
{x,y -> x+y}
3) ๊ณ ์ฐจ ํจ์๋?
fun main(){
println(highfunc({x,y -> x+y}, 10, 20)) //๋๋ค์ ํจ์๋ฅผ ์ธ์๋ก ๋๊ธด๋ค
}
fun highFunc(sum:(Int, Int)-> Int, a: Int, b:Int): Int = sum(a,b) //sum ๋งค๊ฐ๋ณ์๋ ํจ์!
์์๋ฅผ ๋ฐ๊ฟ์ ์จ๋ ๋๋ค!