함수
Kotlin에서 함수를 선언하려면 다음과 같이 합니다.
fun키워드를 사용합니다.- 괄호
()안에 매개변수를 지정합니다. - 필요한 경우 반환 타입을 포함합니다.
예를 들면 다음과 같습니다.
// 'double'은 함수의 이름입니다.
// 'x'는 Int 타입의 매개변수입니다.
// 반환값 또한 Int 타입입니다.
fun double(x: Int): Int {
return 2 * x
}
fun main() {
println(double(5))
// 10
}함수 사용
함수는 일반적인 방식으로 호출합니다.
val result = double(2)멤버 함수 또는 확장 함수를 호출할 때는 점 . 표기법을 사용합니다.
// Stream 클래스의 인스턴스를 생성하고 read()를 호출합니다.
Stream().read()매개변수
함수 매개변수는 파스칼 표기법인 name: Type 형태로 선언합니다. 매개변수는 쉼표로 구분해야 하며, 각 매개변수의 타입을 명시적으로 지정해야 합니다.
fun powerOf(number: Int, exponent: Int): Int { /*...*/ }객체를 함수로 전달하면 컴파일러는 해당 객체에 대한 참조의 복사본을 전달합니다. 복사된 참조는 동일한 객체를 가리키므로, 함수 내에서 해당 객체의 가변(mutable) 상태를 수정할 수 있습니다.
함수 매개변수는 함수 본문 내에서 읽기 전용(암묵적으로 val로 선언됨)이므로 재할당할 수 없습니다.
class Counter(var value: Int)
fun reset(counter: Counter) {
counter.value = 0 // 허용됨: 객체의 상태를 수정합니다.
counter = Counter(0) // 오류: 'val'은 재할당할 수 없습니다.
}함수 매개변수를 선언할 때 후행 쉼표(trailing comma)를 사용할 수 있습니다.
fun powerOf(
number: Int,
exponent: Int, // 후행 쉼표
) { /*...*/ }후행 쉼표는 리팩터링 및 코드 유지보수에 유용합니다. 어떤 매개변수가 마지막이 될지 신경 쓰지 않고도 선언 내에서 매개변수의 순서를 쉽게 변경할 수 있습니다.
Kotlin 함수는 다른 함수를 매개변수로 받을 수 있으며, 인자로 전달될 수도 있습니다. 자세한 내용은 고차 함수와 람다를 참조하세요.
기본값이 있는 매개변수
함수 매개변수에 기본값을 지정하여 선택적 매개변수로 만들 수 있습니다. 해당 매개변수에 대응하는 인자를 전달하지 않고 함수를 호출하면 Kotlin은 기본값을 사용합니다. 기본값이 있는 매개변수를 _선택적 매개변수(optional parameters)_라고도 합니다.
선택적 매개변수를 사용하면 적절한 기본값을 건너뛰기 위해 여러 버전의 함수를 오버로드할 필요가 없으므로 오버로드 횟수를 줄일 수 있습니다.
매개변수 선언 뒤에 =를 붙여 기본값을 설정합니다.
fun read(
b: ByteArray,
// 'off'의 기본값은 0입니다.
off: Int = 0,
// 'len'의 기본값은 'b' 배열의 크기로
// 계산됩니다.
len: Int = b.size,
) { /*...*/ }기본값이 있는 매개변수를 기본값이 없는 매개변수보다 앞에 선언한 경우, 이름 있는 인자를 사용해야만 기본값을 적용할 수 있습니다.
fun greeting(
userId: Int = 0,
message: String,
) { /*...*/ }
fun main() {
// 'userId'의 기본값으로 0을 사용합니다.
greeting(message = "Hello!")
// 오류: 'message' 매개변수에 전달된 값이 없습니다.
greeting("Hello!")
}후행 람다(trailing lambdas)는 이 규칙의 예외이며, 마지막 매개변수는 전달된 함수에 대응해야 합니다.
fun main () {
fun greeting(
userId: Int = 0,
message: () -> Unit,
)
{ println(userId)
message() }
// 'userId'의 기본값을 사용합니다.
greeting() { println ("Hello!") }
// 0
// Hello!
}오버라이딩 메서드는 항상 상위 메서드의 기본 매개변수 값을 사용합니다. 기본 매개변수 값이 있는 메서드를 재정의할 때는 메서드 시그니처에서 기본 매개변수 값을 생략해야 합니다.
open class Shape {
open fun draw(width: Int = 10, height: Int = 5) { /*...*/ }
}
class Rectangle : Shape() {
// 여기서는 기본값을 지정할 수 없지만,
// 이 함수 역시 기본적으로 'width'에 10, 'height'에 5를
// 사용합니다.
override fun draw(width: Int, height: Int) { /*...*/ }
}비상수 표현식을 기본값으로 사용
매개변수에 상수가 아닌 기본값을 지정할 수도 있습니다. 예를 들어, 다음 예제의 len 매개변수처럼 다른 인자의 값을 사용하는 계산이나 함수 호출의 결과를 기본값으로 지정할 수 있습니다.
fun read(
b: ByteArray,
off: Int = 0,
len: Int = b.size,
) { /*...*/ }다른 매개변수의 값을 참조하는 매개변수는 순서상 나중에 선언되어야 합니다. 이 예제에서 len은 반드시 b 뒤에 선언되어야 합니다.
일반적으로 매개변수의 기본값으로 모든 표현식을 지정할 수 있습니다. 그러나 기본값은 해당 매개변수 없이 함수가 호출되어 기본값을 대입해야 할 때만 평가됩니다. 예를 들어, 다음 함수는 print 매개변수 없이 호출될 때만 문자열을 출력합니다.
fun main() {
fun read(
b: Int,
print: Unit? = println("No argument passed for 'print'")
) { println(b) }
// "No argument passed for 'print'"를 출력한 후 "1"을 출력합니다.
read(1)
// "1"만 출력합니다.
read(1, null)
}함수 선언의 마지막 매개변수가 함수형 타입인 경우, 해당하는 람다 인자를 이름 있는 인자로 전달하거나 괄호 바깥으로 전달할 수 있습니다.
fun main() {
fun log(
level: Int = 0,
code: Int = 1,
action: () -> Unit,
) { println (level)
println (code)
action() }
// 'level'에는 1을 전달하고 'code'에는 기본값 1을 사용합니다.
log(1) { println("Connection established") }
// 두 기본값을 모두 사용합니다. 'level'에는 0, 'code'에는 1을 사용합니다.
log(action = { println("Connection established") })
// 이전 호출과 동일하며 두 기본값을 모두 사용합니다.
log { println("Connection established") }
}이름 있는 인자
함수를 호출할 때 하나 이상의 인자에 이름을 지정할 수 있습니다. 이는 함수 호출에 전달해야 할 인자가 많을 때 유용합니다. 인자가 많은 경우, 특히 null이나 불리언 값인 경우 어떤 값이 어떤 인자에 대응하는지 파악하기 어렵기 때문입니다.
함수 호출 시 이름 있는 인자를 사용하면 원하는 순서대로 나열할 수 있습니다.
기본값이 있는 4개의 인자를 가진 reformat() 함수를 살펴보겠습니다.
fun reformat(
str: String,
normalizeCase: Boolean = true,
upperCaseFirstLetter: Boolean = true,
divideByCamelHumps: Boolean = false,
wordSeparator: Char = ' ',
) { /*...*/ }이 함수를 호출할 때 일부 인자에 이름을 지정할 수 있습니다.
reformat(
"String!",
normalizeCase = false,
upperCaseFirstLetter = false,
divideByCamelHumps = true,
'_'
)기본값이 있는 모든 인자를 건너뛸 수도 있습니다.
reformat("This is a long String!")기본값이 있는 인자를 전부 생략하는 대신 일부만 건너뛸 수도 있습니다. 다만, 첫 번째로 건너뛴 인자 이후의 모든 인자에는 이름을 지정해야 합니다.
reformat(
"This is a short String!",
upperCaseFirstLetter = false,
wordSeparator = '_'
)해당 인자의 이름을 지정하여 가변 인자(vararg)를 전달할 수도 있습니다. 이 예제에서는 배열을 전달합니다.
fun mergeStrings(vararg strings: String) { /*...*/ }
mergeStrings(strings = arrayOf("a", "b", "c"))JVM에서 Java 함수를 호출할 때는 이름 있는 인자 구문을 사용할 수 없습니다. Java 바이트코드가 함수 매개변수의 이름을 항상 보존하지는 않기 때문입니다.
반환 타입
중괄호 {} 안에 명령문을 배치하는 블록 본문(block body)으로 함수를 선언할 때는 항상 반환 타입을 명시적으로 지정해야 합니다. 유일한 예외는 함수가 Unit을 반환하는 경우이며, 이 경우에는 반환 타입 지정을 생략할 수 있습니다.
Kotlin은 블록 본문을 가진 함수의 반환 타입을 추론하지 않습니다. 이러한 함수는 제어 흐름이 복잡할 수 있어 읽는 사람뿐만 아니라 컴파일러에게도 반환 타입이 불분명할 수 있기 때문입니다. 그러나 단일 표현식 함수의 경우 반환 타입을 명시하지 않아도 Kotlin이 추론할 수 있습니다.
Kotlin 함수는 단일 값을 반환하지만, 그 값에 여러 데이터 조각이 포함될 수 있습니다. 이러한 값을 표현하는 방법은 여러 값 반환하기를 참조하세요.
여러 값 반환하기
의미가 서로 다른 여러 관련 값을 반환해야 할 때는 단 하나의 함수에서만 사용하더라도 데이터 클래스(data class)를 선언하세요.
data class OrderSummary(
val subtotal: Double,
val tax: Double,
)
fun calculateOrderSummary(prices: List<Double>): OrderSummary {
val subtotal = prices.sum()
val tax = subtotal * 0.2
return OrderSummary(subtotal, tax)
}
fun main() {
val summary = calculateOrderSummary(listOf(12.50, 8.00, 4.50))
println(summary.subtotal)
// 25.0
println(summary.tax)
// 5.0
}데이터 클래스는 의미가 구분되는 여러 값을 반환할 때 적합합니다. 반환되는 값들이 동일한 종류이고 이를 하나의 그룹으로 다루고자 한다면 컬렉션을 반환하는 것을 고려해 보세요.
data class Person(val name: String)
val friendGroups = listOf(
listOf(Person("Alice"), Person("Bob")),
listOf(Person("Charlie"), Person("Diana"), Person("Eve")),
listOf(Person("Frank"))
)
fun findLargestGroupOfFriends(): List<Person> {
return friendGroups.maxByOrNull { it.size } ?: emptyList()
}
fun main() {
val largestGroup = findLargestGroupOfFriends()
println(largestGroup.map { it.name })
// [Charlie, Diana, Eve]
}정해진 개수의 값을 반환해야 한다면 표준 라이브러리의 Pair 또는 Triple 데이터 클래스를 사용할 수도 있습니다. 그러나 이들의 프로퍼티는 first, second, third와 같은 일반적인 이름을 가지므로 결과를 이해하기 어려울 수 있습니다.
예를 들어 calculateOrderTotals() 함수가 Pair를 반환하더라도 각 Double이 무엇을 나타내는지 명확하지 않습니다.
fun calculateOrderTotals(prices: List<Double>): Pair<Double, Double> {
val subtotal = prices.sum()
val tax = subtotal * 0.2
return Pair(subtotal, tax)
}
fun main() {
val totals = calculateOrderTotals(listOf(12.50, 8.00, 4.50))
// 'first'가 무엇을 의미하는가?
println(totals.first)
// 25.0
// 'second'가 무엇을 의미하는가?
println(totals.second)
// 5.0
}명확한 의미를 가진 결과를 반환할 때는 OrderSummary 데이터 클래스 예제에서 본 것처럼 설명적인 프로퍼티 이름을 가진 데이터 클래스를 사용하는 것이 좋습니다.
단일 표현식 함수
함수 본문이 단일 표현식으로 구성된 경우 중괄호를 생략하고 = 기호 뒤에 본문을 지정할 수 있습니다.
fun double(x: Int): Int = x * 2대부분의 경우 반환 타입을 명시적으로 선언하지 않아도 됩니다.
// 컴파일러가 함수가 Int를 반환함을 추론합니다.
fun double(x: Int) = x * 2컴파일러가 단일 표현식에서 반환 타입을 추론할 때 간혹 문제가 발생할 수 있습니다. 이러한 경우에는 반환 타입을 명시적으로 작성해야 합니다. 예를 들어 재귀 함수나 상호 재귀(서로를 호출하는) 함수, 그리고 fun empty() = null과 같이 타입이 없는 표현식을 가진 함수는 항상 반환 타입이 필요합니다.
추론된 반환 타입을 사용할 때는 실제 결과를 반드시 확인하세요. 컴파일러가 의도와 다른 덜 유용한 타입을 추론할 수도 있기 때문입니다. 위의 예제에서 double() 함수가 Int 대신 Number를 반환하도록 하려면 이를 명시적으로 선언해야 합니다.
표현식 본문 내에서 return 문을 사용하는 경우에는 반환 타입을 명시적으로 지정해야 합니다.
fun getDisplayNameOrDefault(userId: String?): String =
getDisplayName(userId ?: return "default")Unit을 반환하는 함수
함수에 블록 본문이 있고 명시적인 반환 타입이 지정되지 않은 경우, 컴파일러는 반환 타입을 Unit으로 추론합니다.
Unit은 Unit이라는 단 하나의 값만 가지는 타입입니다. 이 값은 객체이므로 단 하나의 Unit 인스턴스만 존재합니다. 다른 프로그래밍 언어의 void와 달리 Unit은 실제 타입이며, 코드에서 값이 필요할 때 이 값을 사용할 수 있습니다. 따라서 결과를 생성하는 함수와 작업만 수행하는 함수가 동일한 타입 모델에 들어맞게 됩니다. 즉, 둘 다 값을 반환하며 함수 타입으로 표현되거나 제네릭 API와 함께 사용될 수 있습니다.
함수 선언에서 Unit을 지정하거나 그 값을 명시적으로 반환할 필요는 없습니다. 그러나 () -> Unit과 같이 함수 타입의 일부일 때는 반드시 Unit을 지정해야 합니다. 예를 들어, Unit을 반환하지 않고 printHello() 함수를 선언해 보겠습니다.
// 함수형 타입 매개변수('action')의 선언에는
// 여전히 명시적인 반환 타입이 필요합니다.
fun printHello(name: String?, action: () -> Unit) {
if (name != null)
println("Hello $name")
else
println("Hi there!")
action()
}
fun main() {
printHello("Kodee") {
println("This runs after the greeting.")
// Hello Kodee
// This runs after the greeting.
}
printHello(null) {
println("No name provided, but action still runs.")
// Hi there!
// No name provided, but action still runs.
}
}이는 반환 타입과 값을 명시적으로 지정한 아래의 더 장황한 선언과 동일합니다.
// `() -> Unit` 함수 타입에는 `Unit`이 필수이지만,
// `printHello()`의 반환 타입으로 `: Unit`을 선언하는 것은 선택 사항입니다.
fun printHello(name: String?, action: () -> Unit): Unit {
if (name != null)
println("Hello $name")
else
println("Hi there!")
action()
// `Unit` 값을 명시적으로 반환하는 것은 선택 사항입니다.
return Unit
}
fun main() {
printHello("Kodee") {
println("This action runs when a name is given.")
// Hello Kodee
// This action runs when a name is given.
}
printHello(null) {
println("This action runs when no name is provided.")
// Hi there!
// This action runs when no name is provided.
}
}가변 인자 (varargs)
함수에 가변 개수의 인자를 전달하려면 매개변수 중 하나(보통 마지막 매개변수)를 vararg 수식어로 표시할 수 있습니다. 함수 내부에서 T 타입의 vararg 매개변수는 T의 배열로 사용할 수 있습니다.
fun <T> asList(vararg ts: T): List<T> {
val result = ArrayList<T>()
for (t in ts) // ts는 Array입니다.
result.add(t)
return result
}이제 함수에 가변 개수의 인자를 전달할 수 있습니다.
fun <T> asList(vararg ts: T): List<T> {
val result = ArrayList<T>()
for (t in ts) // ts는 Array입니다.
result.add(t)
return result
}
fun main() {
val list = asList(1, 2, 3)
println(list)
// [1, 2, 3]
}단 하나의 매개변수만 vararg로 표시할 수 있습니다. 매개변수 목록의 마지막이 아닌 위치에 vararg 매개변수를 선언하는 경우, 뒤따르는 매개변수들의 값은 이름 있는 인자를 사용하여 전달해야 합니다. 매개변수가 함수형 타입인 경우 괄호 바깥에 람다를 배치하여 값을 전달할 수도 있습니다.
vararg 함수를 호출할 때는 asList(1, 2, 3) 예제처럼 인자를 개별적으로 전달할 수 있습니다. 이미 배열이 있고 그 내용을 vararg 매개변수 또는 그 일부로 함수에 전달하려면 배열 이름 앞에 *를 붙여 스프레드 연산자(spread operator)를 사용하세요.
fun <T> asList(vararg ts: T): List<T> {
val result = ArrayList<T>()
for (t in ts)
result.add(t)
return result
}
fun main() {
val a = arrayOf(1, 2, 3)
// 함수는 [-1, 0, 1, 2, 3, 4] 배열을 받습니다.
list = asList(-1, 0, *a, 4)
println(list)
// [-1, 0, 1, 2, 3, 4]
}원시 타입 배열(primitive type array)을 vararg로 전달하려면 .toTypedArray() 함수를 사용하여 일반(타입이 지정된) 배열로 변환해야 합니다.
// 'a'는 원시 타입 배열인 IntArray입니다.
val a = intArrayOf(1, 2, 3)
val list = asList(-1, 0, *a.toTypedArray(), 4)중위 표기법 (Infix notation)
infix 키워드를 사용하면 괄호나 점 없이 호출할 수 있는 함수를 선언할 수 있습니다. 이를 통해 코드 내의 간단한 함수 호출을 더 읽기 쉽게 만들 수 있습니다.
infix fun Int.shl(x: Int): Int { /*...*/ }
// 일반적인 표기법을 사용하여 함수를 호출합니다.
1.shl(2)
// 중위 표기법을 사용하여 함수를 호출합니다.
1 shl 2중위 함수는 다음 요구 사항을 충족해야 합니다.
중위 함수 호출은 산술 연산자, 타입 캐스트 및 rangeTo 연산자보다 우선순위가 낮습니다. 다음 표현식들은 서로 동일합니다.
1 shl 2 + 3은1 shl (2 + 3)과 같습니다.0 until n * 2는0 until (n * 2)와 같습니다.xs union ys as Set<*>는xs union (ys as Set<*>)과 같습니다.
반면, 중위 함수 호출의 우선순위는 불리언 연산자 && 및 ||, is 및 in 검사, 그리고 일부 다른 연산자보다 높습니다. 다음 표현식들 역시 서로 동일합니다.
a && b xor c는a && (b xor c)와 같습니다.a xor b in c는(a xor b) in c와 같습니다.
중위 함수는 항상 수신 객체(receiver)와 매개변수를 모두 명시해야 합니다. 중위 표기법을 사용하여 현재 수신 객체에서 메서드를 호출할 때는 모호하지 않은 파싱을 위해 this를 명시적으로 사용하세요.
class MyStringCollection {
val items = mutableListOf<String>()
infix fun add(s: String) {
println("Adding: $s")
items += s
}
fun build() {
add("first") // 올바름: 일반적인 함수 호출
this add "second" // 올바름: 명시적 수신 객체가 있는 중위 호출
// add "third" // 컴파일러 오류: 명시적 수신 객체가 필요함
}
fun printAll() = println("Items = $items")
}
fun main() {
val myStrings = MyStringCollection()
// 리스트에 "first"와 "second"를 추가합니다.
myStrings.build()
myStrings.printAll()
// Adding: first
// Adding: second
// Items = [first, second]
}함수 스코프
Kotlin 함수는 파일의 최상위(top level)에서 선언할 수 있으므로, 함수를 담기 위한 클래스를 생성할 필요가 없습니다. 함수는 _멤버 함수_나 _확장 함수_뿐만 아니라 로컬 함수로도 선언할 수 있습니다.
로컬 함수
Kotlin은 다른 함수 내부에 선언된 함수인 로컬 함수(local functions)를 지원합니다. 예를 들어, 다음 코드는 주어진 그래프에 대한 깊이 우선 탐색(DFS) 알고리즘을 구현합니다. 외부 dfs() 함수 내부의 로컬 dfs() 함수는 구현 세부 사항을 숨기고 재귀 호출을 처리합니다.
class Person(val name: String) {
val friends = mutableListOf<Person>()
}
class SocialGraph(val people: List<Person>)
fun dfs(graph: SocialGraph) {
fun dfs(current: Person, visited: MutableSet<Person>) {
if (!visited.add(current)) return
println("Visited ${current.name}")
for (friend in current.friends)
dfs(friend, visited)
}
dfs(graph.people[0], HashSet())
}
fun main() {
val alice = Person("Alice")
val bob = Person("Bob")
val charlie = Person("Charlie")
alice.friends += bob
bob.friends += charlie
charlie.friends += alice
val network = SocialGraph(listOf(alice, bob, charlie))
dfs(network)
}로컬 함수는 외부 함수의 로컬 변수(클로저)에 접근할 수 있습니다. 위의 경우 visited 함수 매개변수를 다음과 같이 로컬 변수로 변경할 수 있습니다.
class Person(val name: String) {
val friends = mutableListOf<Person>()
}
class SocialGraph(val people: List<Person>)
fun dfs(graph: SocialGraph) {
val visited = HashSet<Person>()
fun dfs(current: Person) {
if (!visited.add(current)) return
println("Visited ${current.name}")
for (friend in current.friends)
dfs(friend)
}
dfs(graph.people[0])
}
fun main() {
val alice = Person("Alice")
val bob = Person("Bob")
val charlie = Person("Charlie")
alice.friends += bob
bob.friends += charlie
charlie.friends += alice
val network = SocialGraph(listOf(alice, bob, charlie))
dfs(network)
}멤버 함수
멤버 함수는 클래스나 객체 내부에 정의된 함수입니다.
class Sample {
fun foo() { print("Foo") }
}멤버 함수를 호출하려면 인스턴스 또는 객체 이름을 작성한 후 점 .을 찍고 함수 이름을 적습니다.
// Stream 클래스의 인스턴스를 생성하고 read()를 호출합니다.
Stream().read()클래스 및 멤버 재정의에 대한 자세한 내용은 클래스 및 상속을 참조하세요.
제네릭 함수
함수 이름 앞에 꺾쇠괄호 <>를 사용하여 함수의 제네릭 매개변수를 지정할 수 있습니다.
fun <T> singletonList(item: T): List<T> { /*...*/ }제네릭 함수에 대한 자세한 내용은 제네릭을 참조하세요.
꼬리 재귀 함수
Kotlin은 꼬리 재귀(tail recursion)로 알려진 함수형 프로그래밍 스타일을 지원합니다. 보통 루프를 사용하는 일부 알고리즘의 경우, 스택 오버플로 위험 없이 재귀 함수를 대신 사용할 수 있습니다. 함수에 tailrec 수식어가 지정되고 필요한 정형 조건을 만족하면, 컴파일러가 재귀를 최적화하여 빠르고 효율적인 루프 기반 버전으로 대체합니다.
import kotlin.math.cos
import kotlin.math.abs
// 임의의 "충분히 정밀한" 정밀도 값
val eps = 1E-10
tailrec fun findFixPoint(x: Double = 1.0): Double =
if (abs(x - cos(x)) < eps) x else findFixPoint(cos(x))이 코드는 코사인 함수의 고정점(수학 상수)을 계산합니다. 이 함수는 결과가 더 이상 변하지 않을 때까지 1.0부터 시작하여 cos()를 반복 호출하며, 지정된 eps 정밀도에 대해 0.7390851332151611이라는 결과를 냅니다. 이 코드는 전통적인 스타일의 다음 코드와 동일합니다.
import kotlin.math.cos
import kotlin.math.abs
// 임의의 "충분히 정밀한" 정밀도 값
val eps = 1E-10
private fun findFixPoint(): Double {
var x = 1.0
while (true) {
val y = cos(x)
if (abs(x - y) < eps) return x
x = cos(x)
}
}tailrec 수식어는 함수가 마지막 작업으로 자기 자신을 호출할 때만 적용할 수 있습니다. 재귀 호출 뒤에 추가 코드가 있는 경우, try/catch/finally 블록 내에 있는 경우, 또는 함수가 open되어 있는 경우에는 꼬리 재귀를 사용할 수 없습니다.
함께 보기:
