03. 함수

🤔함수

fun 함수이름 ([변수 이름: 자료형]): [반환값의 자료형] {
	표현식
    [return 반환값]
}

 

 - 가변 인자: 인자의 개수가 변한다 

fun 함수이름 (vararg [변수 이름: 자료형]): [반환값의 자료형] {
	표현식
    [return 반환값]
}

 

🤔코틀린 == 다중 패러다임 언어

 

1) 함수형 프로그래밍: 코드 간략, 테스트나 재사용성 증가, 람다식, 고차 함수를 사용해 구성, 순수 함수

2) 객체 지향 프로그래밍

 

 

🤔순수 함수

 

부작용(side-effect)이 없는 함수

-> 동일한 입력 인자에 대해서는 항상 같은 결과를 출력, 반환함

-> 값이 예측 가능하여 결정적

 

조건

-> 같은 인자에 대하여 항상 같은 값을 반환

-> 함수 외부의 어떤 상태도 바꾸지 않음 

 

장점

-> 입력, 내용을 분리하고 모듈화 하여 재사용성이 높아짐

-> 특정 상태에 영향 주지 않음 -> 병행 작업 시 안전

-> 함수의 값 추적, 예측 가능 -> 테스트, 디버깅 유리

 

함수형 프로그래밍에 적용

-> 함수를 매개변수, 인자에 혹인 반환 값에 적용 (고차 함수)

-> 함수를 변수나 데이터 구조에 저장

-> 유연성 증가

 

 

🤔람다식

 

- 익명 함수의 하나의 형태로 이름 없이 사용 및 실행이 가능

- 람다 대수로부터 유래

 

이용

-> 람다식은 고차 함수에서 인자로 넘기거나 결과값으로 반환 등을 할 수 있음

 

//일반 변수에 람다식 할당
// 1
val multi={a:Int, b:Int -> a*b}

// 2
val multi:(a:Int, b:Int) -> Int = {a,b -> a*b}

result=multi(a:10, b:20) //람다식이 할당된 변수는 함수처럼 사용 가능

 

- 매개변수 개수에 따라 람다식을 구성하는 방법

fun main(){
	//매개변수 없는 람다식 함수
    noParam({"Hello World!"})
    noParam {"Hello World!"} //위와 동일 결과, 소괄호 생략 가능
    
    //매개변수가 하나 있는 람다식 함수
    oneParam ({a->"Hello World! $a"})
    oneParam {a->"Hello World! $a"} //위와 동일 결과, 소괄호 생략 가능
    oneParam {"Hello World! $it"} //위와 동일 결과, it으로 대체 가능
    
    //매개변수가 두 개 있는 람다식 함수
    moreParam {a,b -> "Hello World! $a $b"} //매개변수명 생략 불가
    
    //매개변수를 생략하는 경우
    moreParam {_, b -> "Hello World! $b"} //첫 번째 문자열은 사용하지 않고 생략
}

//매개변수가 없는 람다식 함수가 noParam 함수의 매개변수 out 으로 지정됨
fun noParam(out:()->String)=println(out())

//매개변수가 하나 있는 람다식 함수가 oneParam함수의 매개변수 out으로 지정됨
fun oneParam(out: (String) -> String) {
	println(out("OneParam"))
}

//매개변수가 두 개 있는 람다식 함수가 moreParam 함수의 매개변수로 지정됨
fun moreParam(out: (String,String) -> String) {
	println(out("OneParam","TwoParam"))
}

 

🤔일급 객체

 

- 함수의 인자로 전달할 수 있음

- 함수의 반환 값에 사용 가능

- 변수에 담을 수 있음

 

-> 코틀린에서 함수는 일급 객체로 다룸

 

 

🤔고차 함수

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 매개변수는 함수

 

🤔익명 함수

 

- 함수가 이름이 없는 것

- 람다식도 일종의 익명 함수

- 일반 익명 함수에서는 return, break continue가 사용 가능하지만, 람다식에서는 사용하기 어려움

fun (x: Int, y:Int): Int= x+y //함수 이름이 생략된 익명 함수

val add: (Int, Int) -> Int=fun(x,y)=x+y //익명 함수를 사용한 add 선언
val result=add(10,2) //add의 사용

 

 

🤔인라인 함수

 

- 함수가 호출되는 곳에 내용을 모두 복사

- 함수의 분기 없이 처리 -> 성능 증가

- 단점: 코드가 복사되므로 내용이 많은 함수에 사용하면 코드가 늘어남

 

- noinline 키워드: 일부 람다식 함수를 인라인 되지 않게 하기 위해

inline fun sub (out1: () -> Unit, noinline out2: () -> Unit) {

 

 

🤔확장 함수

 

- 클래스의 멤버 함수를 외부에서 더 추가할 수 있다.

- 기존의 표준 라이브러리를 수정하지 않고도 확장 가능

fun 확장대상.함수명(매개변수, ...): 반환값{
	...
    retrun 값
}

 

 

🤔중위 함수

 

- 중위 표현법: 클래스의 멤버 호출 시 사용하는 점(.)을 생략하고 함수 이름 뒤에 소괄호를 생략해 직관적인 이름을 사용할 수 있는 표현범

- 중위 함수의 조건

   -> 멤버 메서드 또는 확장 함수여야 한다.

   -> 하나의 매개변수를 가져야 한다.

   -> infix 키워드를 사용하여 정의한다.

fun main(){
	//중위 표현범
    val multi=3 multiply 10
    println("multi: $multi")
}

//Int 확장해서 multiply() 함수가 하나 더 추가되었음
infix fun Int.multiply(x:Int): Int{ //infix로 선언되므로 중위 함수
	return this*x
}

 

 

🤔꼬리 재귀 함수

 

- 재귀: 자기 자신을 다시 참조/ 재귀 함수는 자기 자신을 계속 호출하는 특징

-꼬리 재귀 함수

   -> 스택에 계속 쌓이는 방식이 함수가 계속 씌워지는 꼬리를 무는 형태

   -> 코틀린 고유의 tailrec 키워드를 사용해 선언

#꼬리 재귀 - 스택을 사용하지 않음

fun main() {
    val number=5
    println("Factorial: $number -> ${factorial(number)}")
}

tailrec fun factorial(n: Int, run: Int=1): Long {
	return if (n==1) run.toLong() else factorial(n-1, run*n)
}

 

🤔함수의 실행 블록

 

- 함수의 블록({}): 블록 내에서 사용하는 변수 - 지역 변수

- 최상위 및 지역 함수 사용 범위

   -> 최상위 함수는 main() 함수 전, 후 어디든 선언하고 코드 내에서 호출 가능

   -> 지역 함수는 먼저 선언되어야 그 함수를 호출할 수 있음

 

- 전역 변수

   -> 최상위에 있는 변수로 프로그램이 실행되는 동안 삭제되지 않고 메모리에 유지

   -> 여러 요소가 동시에 접근하는 경우에 잘못된 동작을 유발 가능

   -> 자주 사용되지 않는 전역 변수는 메모리 자원 낭비

- 지역변수

   -> 특정 코드 블록 내에서만 사용

   -> 블록 시작 시 임시로 사용되며 주로 스택 메모리를 사용

 

 

---

출처) www.boostcourse.org/mo132

코틀린 프로그래밍 기본 1