Kotlin에서 함수 유형 및 람다 표현식 사용

1. 소개

이 Codelab에서는 함수 유형, 함수 유형 사용 방법, 람다 표현식과 관련된 문법에 관해 알아봅니다.

Kotlin에서 함수는 최고 수준의 구성체로 간주됩니다. 이는 함수를 데이터 유형으로 간주할 수 있다는 의미입니다. 함수를 변수에 저장하고 저장한 함수를 다른 함수에 인수로 전달하며 다른 함수에서 그것을 반환할 수 있습니다.

리터럴 값으로 표현할 수 있는 다른 데이터 유형(예: 10 값의 Int 유형과 "Hello" 값의 String 유형)과 마찬가지로 함수 리터럴을 선언할 수도 있습니다. 이를 람다 표현식 또는 줄여서 람다라고 합니다. 람다 표현식은 Android 개발에서 광범위하게 사용되고 Kotlin 프로그래밍에서는 보다 일반적으로 사용됩니다.

기본 요건

  • 함수, if/else 문, null 허용 여부를 비롯하여 Kotlin 프로그래밍에 관한 지식

학습할 내용

  • 람다 문법으로 함수를 정의하는 방법
  • 변수에 함수를 저장하는 방법
  • 함수를 다른 함수에 인수로 전달하는 방법
  • 다른 함수에서 함수를 반환하는 방법
  • null을 허용하는 함수 유형을 사용하는 방법
  • 람다 표현식을 더 간결하게 만드는 방법
  • 고차 함수의 정의
  • repeat() 함수 사용 방법

필요한 항목

  • Kotlin 플레이그라운드에 액세스할 수 있는 웹브라우저

2. 코드 따라 하기 동영상 시청(선택사항)

교육 과정 강사가 Codelab을 완료하는 모습을 보려면 아래 동영상을 재생하세요.

Kotlin Playground와 코드를 더 선명하게 볼 수 있도록 동영상을 전체 화면으로 확대하는 것이 좋습니다(동영상 모서리에 있는 이 기호는 전체 화면 모드를 나타내기 위해 정사각형의 네 개 모서리가 강조표시되어 있음을 보여줍니다. 아이콘 사용).

이 단계는 선택사항입니다. 이 동영상을 건너뛰고 Codelab 안내를 바로 시작할 수도 있습니다.

3. 변수에 함수 저장

지금까지는 fun 키워드를 사용하여 함수를 선언하는 방법을 배웠습니다. fun 키워드로 선언된 함수를 호출할 수 있으며, 이렇게 할 경우 함수 본문의 코드가 실행됩니다.

최고 수준의 구성체인 함수도 데이터 유형입니다. 따라서 변수에 함수를 저장하고 저장된 함수를 다른 함수에 전달하고 그것을 함수에서 반환할 수 있습니다. 이전 Codelab에서 했던 것처럼, 런타임 시 앱 동작을 변경하거나 구성 가능한 함수를 중첩하여 레이아웃을 빌드하고자 할 수 있습니다. 이 모든 작업은 람다 표현식으로 가능합니다.

이는 trick-or-treating을 사용해 실제로 확인할 수 있습니다. trick-or-treating은 많은 국가의 핼러윈 전통으로, 이날에는 아이들이 분장을 하고 집집마다 돌아다니며 '과자를 주지 않으면 장난칠 것'이라고 말하면서 대개 사탕을 얻습니다.

다음과 같이 변수에 함수를 저장합니다.

  1. Kotlin 플레이그라운드로 이동합니다.
  2. main() 함수 다음에 매개변수와 반환 값이 없으며 "No treats!"를 출력하는 trick() 함수를 정의합니다. 이 문법은 이전 Codelab에서 본 다른 함수의 문법과 동일합니다.
fun main() {

}

fun trick() {
    println("No treats!")
}
  1. main() 함수의 본문에서 trickFunction이라는 변수를 만들고 trick과 같게 설정합니다. 함수를 호출하지 않고 함수를 변수에 저장하려 하기 때문에 trick 다음에 괄호를 사용하지 않습니다.
fun main() {
    val trickFunction = trick
}

fun trick() {
    println("No treats!")
}
  1. 코드를 실행합니다. Kotlin 컴파일러에서 tricktrick() 함수의 이름으로 인식하지만 변수에 함수가 할당되는 대신 함수가 호출될 것으로 예상하기 때문에 오류가 발생합니다.
Function invocation 'trick()' expected

trickFunction 변수에 trick을 저장하려고 했습니다. 그러나 함수를 값으로 참조하려면 함수 참조 연산자(::)를 사용해야 합니다. 관련 문법은 다음 이미지에 나와 있습니다.

a9a9bfa88485ec67.png

  1. 함수를 값으로 참조하려면 trickFunction::trick에 재할당합니다.
fun main() {
    val trickFunction = ::trick
}

fun trick() {
    println("No treats!")
}
  1. 코드를 실행하여 오류가 더 이상 없는지 확인합니다. trickFunction이 사용되지 않았다는 경고가 발생합니다. 이 문제는 다음 섹션에서 해결할 것입니다.

람다 표현식을 사용하여 함수 재정의

람다 표현식은 fun 키워드 없이 함수를 정의할 수 있는 간결한 문법입니다. 람다 표현식은 다른 함수에 관한 함수 참조 없이 변수에 직접 저장할 수 있습니다.

할당 연산자(=) 앞에 val 또는 var 키워드를 추가하고 그 뒤에 함수를 호출할 때 사용하는 변수 이름을 추가합니다. 할당 연산자(=) 다음에 람다 표현식이 옵니다. 이때 람다 표현식은 함수 본문을 구성하는 한 쌍의 중괄호로 구성됩니다. 관련 문법은 다음 이미지에 나와 있습니다.

5e25af769cc200bc.png

람다 표현식을 사용하여 함수를 정의할 경우 그 함수를 참조하는 변수를 갖게 됩니다. 다른 유형처럼 그 값을 다른 변수에 할당하고 새 변수의 이름으로 함수를 호출할 수도 있습니다.

람다 표현식을 사용하도록 코드를 업데이트합니다.

  1. 람다 표현식을 사용하여 trick() 함수를 다시 작성합니다. 이제 이름 trick은 변수의 이름을 참조합니다. 중괄호 내 함수 본문은 이제 람다 표현식입니다.
fun main() {
    val trickFunction = ::trick
}

val trick = {
    println("No treats!")
}
  1. 이제 trick이 함수 이름이 아닌 변수를 참조하므로 main() 함수에서 함수 참조 연산자(::)를 삭제합니다.
fun main() {
    val trickFunction = trick
}

val trick = {
    println("No treats!")
}
  1. 코드를 실행합니다. 오류가 발생하지 않습니다. 함수 참조 연산자(::) 없이 trick() 함수를 참조할 수 있습니다. 아직 함수를 호출하지 않았기 때문에 출력이 없습니다.
  2. main() 함수에서 trick() 함수를 호출합니다. 이번에는 다른 함수를 호출할 때와 마찬가지로 괄호를 포함합니다.
fun main() {
    val trickFunction = trick
    trick()
}

val trick = {
    println("No treats!")
}
  1. 코드를 실행합니다. 람다 표현식의 본문이 실행됩니다.
No treats!
  1. main() 함수에서 trickFunction 변수를 함수인 것처럼 호출합니다.
fun main() {
    val trickFunction = trick
    trick()
    trickFunction()
}

val trick = {
    println("No treats!")
}
  1. 코드를 실행합니다. 함수는 trick() 함수 호출에 한 번, trickFunction() 함수 호출에 한 번, 이렇게 두 번 호출됩니다.
No treats!
No treats!

람다 표현식을 사용하면 함수를 저장할 변수를 만들고, 이러한 변수를 함수처럼 호출하고, 그것을 다른 변수에 저장하여 함수처럼 호출할 수 있습니다.

4. 함수를 데이터 유형으로 사용

이전 Codelab에서 Kotlin에 유형 추론이 있다고 배웠습니다. 변수를 선언할 때 유형을 명시적으로 지정하지 않아도 되는 경우가 많습니다. 이전 예에서는 Kotlin 컴파일러가 trick의 값이 함수임을 추론할 수 있었습니다. 그러나 함수 매개변수의 유형이나 반환 유형을 지정하려면 함수 유형을 표현하기 위한 문법을 알아야 합니다. 함수 유형은 선택적 매개변수 목록, -> 기호, 반환 유형이 포함된 괄호 쌍으로 구성됩니다. 관련 문법은 다음 이미지에 나와 있습니다.

5608ac5e471b424b.png

앞서 선언한 trick 변수의 데이터 유형은 () -> Unit입니다. 함수에 매개변수가 없으므로 괄호가 비어 있습니다. 그리고 함수에서 아무것도 반환하지 않으므로 반환 유형은 Unit입니다. 두 개의 Int 매개변수를 사용하고 Int를 반환하는 함수이면 데이터 유형은 (Int, Int) -> Int입니다.

함수의 유형을 명시적으로 지정하는 람다 표현식으로 또 다른 함수를 선언합니다.

  1. trick 변수 다음에 treat라는 변수를 선언합니다. 이 변수는 "Have a treat!"를 출력하는 본문을 갖춘 람다 표현식과 같습니다.
val trick = {
    println("No treats!")
}

val treat = {
    println("Have a treat!")
}
  1. treat 변수의 데이터 유형을 () -> Unit로 지정합니다.
val treat: () -> Unit = {
    println("Have a treat!")
}
  1. main() 함수에서 treat() 함수를 호출합니다.
fun main() {
    val trickFunction = trick
    trick()
    trickFunction()
    treat()
}
  1. 코드를 실행합니다. treat() 함수는 trick() 함수처럼 동작합니다. treat 변수만 데이터 유형을 명시적으로 선언하더라도 두 변수의 데이터 유형은 동일합니다.
No treats!
No treats!
Have a treat!

함수를 반환 유형으로 사용

함수가 데이터 유형이므로 다른 데이터 유형처럼 함수를 사용할 수 있습니다. 다른 함수에서 함수도 반환할 수 있습니다. 관련 문법은 다음 이미지에 나와 있습니다.

f16dd6ca0c1588f5.png

함수를 반환하는 함수를 만듭니다.

  1. main() 함수에서 코드를 삭제합니다.
fun main() {

}
  1. main() 함수 다음에 Boolean 유형의 isTrick 매개변수를 허용하는 trickOrTreat() 함수를 정의합니다.
fun main() {

}

fun trickOrTreat(isTrick: Boolean): () -> Unit {
}

val trick = {
    println("No treats!")
}

val treat = {
    println("Have a treat!")
}
  1. trickOrTreat() 함수의 본문에서 isTricktrue이면 trick() 함수를 반환하고 isTrick이 false이면 treat() 함수를 반환하는 if 문을 추가합니다.
fun trickOrTreat(isTrick: Boolean): () -> Unit {
    if (isTrick) {
        return trick
    } else {
        return treat
    }
}
  1. main() 함수에서 treatFunction이라는 변수를 만들어 trickOrTreat() 호출 결과에 할당한 다음 isTrick 매개변수에 관한 false를 전달합니다. 그런 다음 trickFunction이라는 두 번째 변수를 만들어 trickOrTreat() 호출 결과에 할당한 다음 이번에는 isTrick 매개변수에 관한 true를 전달합니다.
fun main() {
    val treatFunction = trickOrTreat(false)
    val trickFunction = trickOrTreat(true)
}
  1. 그다음 줄에서 treatFunction()을 호출한 후 trickFunction()을 호출합니다.
fun main() {
    val treatFunction = trickOrTreat(false)
    val trickFunction = trickOrTreat(true)
    treatFunction()
    trickFunction()
}
  1. 코드를 실행합니다. 다음과 같이 각 함수의 출력이 표시됩니다. trick() 또는 treat() 함수를 직접 호출하지는 않았지만 아직 그러한 변수를 호출할 수 있습니다. trickOrTreat() 함수를 호출할 때마다 반환 값을 저장했으며 trickFunctiontreatFunction 변수를 사용하여 함수를 호출했기 때문입니다.
Have a treat!
No treats!

지금까지 함수가 다른 함수를 어떻게 반환할 수 있는지 알아보았습니다. 함수를 다른 함수에 인수로 전달할 수도 있습니다. 두 문자열 중 하나를 반환하는 것 외에 다른 작업을 하고자 할 때 trickOrTreat() 함수에 맞춤 동작을 제공할 수 있습니다. 다른 함수를 인수로 취하는 함수를 사용하면 그 함수를 호출할 때마다 다른 함수를 전달할 수 있습니다.

함수를 다른 함수에 인수로 전달

핼러윈을 기념하는 일부 지역에서는 아이들이 사탕 대신 잔돈을 받거나 두 가지 모두를 받기도 합니다. 다른 선물도 허용하도록 trickOrTreat() 함수를 수정할 것입니다. 그 선물은 인수 형태로 제공된 함수로 표현됩니다.

trickOrTreat()가 매개변수로 사용하는 함수에도 자체 매개변수가 있어야 합니다. 함수 유형을 선언할 때 매개변수에는 라벨이 지정되지 않습니다. 각 매개변수의 데이터 유형을 쉼표로 구분하여 지정하기만 하면 됩니다. 관련 문법은 다음 이미지에 나와 있습니다.

8372d3b83d539fac.png

매개변수를 취하는 함수에 관한 람다 표현식을 작성할 때 매개변수에 매개변수의 발생 순서대로 이름이 지정됩니다. 매개변수 이름은 여는 중괄호 다음에 나열되고 각 이름은 쉼표로 구분됩니다. 화살표(->)는 함수 본문에서 매개변수 이름을 구분합니다. 관련 문법은 다음 이미지에 나와 있습니다.

938d2adf25172873.png

함수를 매개변수로 사용하도록 trickOrTreat() 함수를 업데이트합니다.

  1. isTrick 매개변수 다음에 (Int) -> String 유형의 extraTreat 매개변수를 추가합니다.
fun trickOrTreat(isTrick: Boolean, extraTreat: (Int) -> String): () -> Unit {
  1. else 블록의 return 문 앞에서 println()을 호출하고 extraTreat() 함수 호출을 전달합니다. 5extraTreat() 호출에 전달합니다.
fun trickOrTreat(isTrick: Boolean, extraTreat: (Int) -> String): () -> Unit {
    if (isTrick) {
        return trick
    } else {
        println(extraTreat(5))
        return treat
    }
}
  1. 이제 trickOrTreat() 함수를 호출할 때 람다 표현식으로 함수를 정의하고 extraTreat 매개변수에 전달해야 합니다. trickOrTreat() 함수를 호출하기 전에 main() 함수에서 coins() 함수를 추가합니다. coins() 함수는 Int 매개변수의 이름을 quantity로 지정하고 String을 반환합니다. 람다 표현식에 사용할 수 없는 return 키워드가 없음을 알 수 있습니다. 대신 함수의 마지막 표현식 결과가 반환 값이 됩니다.
fun main() {
    val coins: (Int) -> String = { quantity ->
        "$quantity quarters"
    }

    val treatFunction = trickOrTreat(false)
    val trickFunction = trickOrTreat(true)
    treatFunction()
    trickFunction()
}
  1. 다음과 같이 coins() 함수 다음에 cupcake() 함수를 추가합니다. Int 매개변수의 이름을 quantity로 지정하고 -> 연산자를 사용하여 함수 본문과 구분합니다. 이제 coins() 함수나 cupcake() 함수를 trickOrTreat() 함수에 전달할 수 있습니다.
fun main() {
    val coins: (Int) -> String = { quantity ->
        "$quantity quarters"
    }

    val cupcake: (Int) -> String = { quantity ->
        "Have a cupcake!"
    }

    val treatFunction = trickOrTreat(false)
    val trickFunction = trickOrTreat(true)
    treatFunction()
    trickFunction()
}
  1. cupcake() 함수에서 quantity 매개변수와 -> 기호를 삭제합니다. 이러한 항목은 사용되지 않으므로 생략해도 됩니다.
val cupcake: (Int) -> String = {
    "Have a cupcake!"
}
  1. trickOrTreat() 함수 호출을 업데이트합니다. 첫 번째 호출의 경우 isTrickfalse이면 coins() 함수를 전달합니다. 두 번째 호출의 경우 isTricktrue이면 cupcake() 함수를 전달합니다.
fun main() {
    val coins: (Int) -> String = { quantity ->
        "$quantity quarters"
    }

    val cupcake: (Int) -> String = {
        "Have a cupcake!"
    }

    val treatFunction = trickOrTreat(false, coins)
    val trickFunction = trickOrTreat(true, cupcake)
    treatFunction()
    trickFunction()
}
  1. 코드를 실행합니다. extraTreat() 함수는 isTrick 매개변수가 false 인수로 설정된 경우에만 호출되므로 출력에는 5 quarters가 포함되지만 cupcake는 포함되지 않습니다.
5 quarters
Have a treat!
No treats!

null을 허용하는 함수 유형

다른 데이터 유형과 마찬가지로 함수 유형도 null을 허용하는 것으로 선언할 수 있습니다. 이러한 경우 변수가 함수를 포함하거나 null일 수 있습니다.

함수를 null을 허용하는 것으로 선언하려면 함수 유형을 괄호로 묶은 다음 닫는 괄호 밖에 ? 기호를 추가합니다. 예를 들어 () -> String 유형을 null을 허용하게 하려면 이를 (() -> String)? 유형으로 선언하면 됩니다. 관련 문법은 다음 이미지에 나와 있습니다.

c8a004fbdc7469d.png

trickOrTreat() 함수를 호출할 때마다 extraTreat() 함수를 제공할 필요가 없도록 extraTreat 매개변수에서 null을 허용하도록 설정합니다.

  1. extraTreat 매개변수의 유형을 (() -> String)?로 변경합니다.
fun trickOrTreat(isTrick: Boolean, extraTreat: ((Int) -> String)?): () -> Unit {
  1. null이 아닌 경우에만 if 문을 사용하여 함수를 호출하도록 extraTreat() 함수 호출을 수정합니다. 이제 trickOrTreat() 함수는 다음 코드 스니펫과 같습니다.
fun trickOrTreat(isTrick: Boolean, extraTreat: ((Int) -> String)?): () -> Unit {
    if (isTrick) {
        return trick
    } else {
        if (extraTreat != null) {
            println(extraTreat(5))
        }
        return treat
    }
}
  1. cupcake() 함수를 삭제하고, trickOrTreat() 함수의 두 번째 호출에서 cupcake 인수를 null로 바꿉니다.
fun main() {
    val coins: (Int) -> String = { quantity ->
        "$quantity quarters"
    }

    val treatFunction = trickOrTreat(false, coins)
    val trickFunction = trickOrTreat(true, null)
    treatFunction()
    trickFunction()
}
  1. 코드를 실행합니다. 출력은 달라지지 않습니다. 이제 함수 유형을 null을 허용하는 것으로 선언할 수 있으므로 더 이상 extraTreat 매개변수를 위해 함수를 전달할 필요가 없습니다.
5 quarters
Have a treat!
No treats!

5. 약식 문법으로 람다 표현식 작성

람다 표현식은 코드를 더 간결하게 작성할 수 있는 다양한 방법을 제공합니다. 직접 보고 작성하는 대부분의 람다 표현식이 약식 문법으로 작성되기 때문에 이 섹션에서는 그중 몇 가지 람다 표현식을 살펴봅니다.

매개변수 이름 생략

coins() 함수를 작성할 때 함수의 Int 매개변수에 이름 quantity를 명시적으로 선언했습니다. 그러나 cupcake() 함수에서 본 것처럼 매개변수 이름을 완전히 생략할 수 있습니다. 함수에 매개변수가 한 개 있고 이름을 지정하지 않는 경우 Kotlin은 암시적으로 매개변수에 it 이름을 할당합니다. 그러니 매개변수 이름과 -> 기호를 생략할 수 있고 그러면 람다 표현식이 더 간결해집니다. 관련 문법은 다음 이미지에 나와 있습니다.

332ea7bade5062d6.png

매개변수에 약식 문법을 사용하도록 coins() 함수를 업데이트합니다.

  1. coins() 함수에서 quantity 매개변수 이름과 -> 기호를 삭제합니다.
val coins: (Int) -> String = {
    "$quantity quarters"
}
  1. $it를 사용하는 단일 매개변수를 참조하도록 "$quantity quarters" 문자열 템플릿을 변경합니다.
val coins: (Int) -> String = {
    "$it quarters"
}
  1. 코드를 실행합니다. Kotlin은 Int 매개변수의 it 매개변수 이름을 인식하고 계속해서 동전(quarter) 수를 출력합니다.
5 quarters
Have a treat!
No treats!

람다 표현식을 함수에 직접 전달

coins() 함수는 현재 한 곳에만 사용됩니다. 처음에 변수를 만들지 않고도 람다 표현식을 trickOrTreat() 함수에 직접 전달할 수 있다면 어떨까요?

람다 표현식은 함수 리터럴일 뿐입니다. 예를 들어 0은 정수 리터럴이고 "Hello"는 문자열 리터럴입니다. 람다 표현식을 함수 호출에 직접 전달할 수 있습니다. 관련 문법은 다음 이미지에 나와 있습니다.

39dc1086e2471ffc.png

coins 변수를 삭제할 수 있도록 코드를 수정합니다.

  1. 람다 표현식이 trickOrTreat() 함수 호출에 직접 전달되도록 람다 표현식을 이동합니다. 람다 표현식을 한 줄로 압축할 수도 있습니다.
fun main() {
    val coins: (Int) -> String = {
        "$it quarters"
    }
    val treatFunction = trickOrTreat(false, { "$it quarters" })
    val trickFunction = trickOrTreat(true, null)
    treatFunction()
    trickFunction()
}
  1. coins 변수는 더 이상 사용되지 않으므로 삭제합니다.
fun main() {
    val treatFunction = trickOrTreat(false, { "$it quarters" })
    val trickFunction = trickOrTreat(true, null)
    treatFunction()
    trickFunction()
}
  1. 코드를 실행합니다. 여전히 예상대로 컴파일되고 실행됩니다.
5 quarters
Have a treat!
No treats!

후행 람다 문법 사용

함수 유형이 함수의 마지막 매개변수인 경우 다른 축약 옵션을 사용하여 람다를 작성할 수 있습니다. 이 경우 닫는 괄호 다음에 람다 표현식을 배치하여 함수를 호출할 수 있습니다. 관련 문법은 다음 이미지에 나와 있습니다.

3ee3176d612b54.png

이렇게 하면 람다 표현식이 다른 매개변수와 구분되므로 코드를 더 쉽게 읽을 수 있으며 코드 기능은 변경되지 않습니다.

후행 람다 문법을 사용하도록 코드를 업데이트합니다.

  1. treatFunction 변수에서 람다 표현식 {"$it quarters"}trickOrTreat() 호출의 닫는 괄호 다음으로 이동합니다.
val treatFunction = trickOrTreat(false) { "$it quarters" }
  1. 코드를 실행합니다. 여전히 모두 제대로 작동합니다.
5 quarters
Have a treat!
No treats!

6. repeat() 함수 사용

함수가 함수를 반환하거나 또는 함수를 인수로 취하는 경우 이를 고차 함수라고 합니다. trickOrTreat() 함수가 ((Int) -> String)? 유형의 함수를 매개변수로 취하고 () -> Unit 유형의 함수를 반환하므로 고차 함수의 예입니다. Kotlin에서는 새로 얻은 람다 지식으로 활용할 수 있는 유용한 고차 함수를 다양하게 제공합니다.

repeat() 함수는 이러한 고차 함수 중 하나입니다. repeat() 함수는 함수로 for 루프를 표현할 수 있는 간결한 방법입니다. 이후 단원에서 이 함수와 다른 고차 함수를 자주 사용하게 됩니다. repeat() 함수에는 다음과 같은 함수 서명이 있습니다.

repeat(times: Int, action: (Int) -> Unit)

times 매개변수는 동작이 발생해야 하는 횟수입니다. action 매개변수는 단일 Int 매개변수를 사용하고 Unit 유형을 반환하는 함수입니다. action 함수의 Int 매개변수는 동작이 지금까지 실행된 횟수입니다(예: 첫 번째 반복에서는 0 인수, 두 번째 반복에서는 1 인수). repeat() 함수를 사용하면 for 루프와 유사하게 지정된 횟수만큼 코드를 반복할 수 있습니다. 관련 문법은 다음 이미지에 나와 있습니다.

519a2e0f5d02687.png

trickFunction() 함수를 한 번만 호출하는 대신 repeat() 함수를 사용하여 여러 번 호출할 수 있습니다.

repeat() 함수가 어떻게 작동하는지 확인하기 위해 trick-or-treating 코드를 업데이트합니다.

  1. main() 함수에서 treatFunction() 호출과 trickFunction() 호출 중간에 repeat() 함수를 호출합니다. times 매개변수에 4를 전달하고 action 함수에 후행 람다 문법을 사용합니다. 람다 표현식의 Int 매개변수에 이름을 지정할 필요는 없습니다.
fun main() {
    val treatFunction = trickOrTreat(false) { "$it quarters" }
    val trickFunction = trickOrTreat(true, null)
    treatFunction()
    trickFunction()
    repeat(4) {

    }
}
  1. treatFunction() 함수 호출을 repeat() 함수의 람다 표현식으로 이동합니다.
fun main() {
    val treatFunction = trickOrTreat(false) { "$it quarters" }
    val trickFunction = trickOrTreat(true, null)
    repeat(4) {
        treatFunction()
    }
    trickFunction()
}
  1. 코드를 실행합니다. "Have a treat" 문자열이 4번 출력됩니다.
5 quarters
Have a treat!
Have a treat!
Have a treat!
Have a treat!
No treats!

7. 결론

축하합니다. 함수 유형 및 람다 표현식의 기본사항을 알아봤습니다. 이러한 개념을 잘 알고 있으면 Kotlin 언어에 관해 자세히 배울 때 도움이 됩니다. 또한 함수 유형과 고차 함수, 약식 문법을 사용하여 코드를 더 간결하고 읽기 쉽게 만들 수 있습니다.

요약

  • Kotlin의 함수는 최고 구성체이며 데이터 유형처럼 처리할 수 있습니다.
  • 람다 표현식은 함수를 작성하는 약식 문법을 제공합니다.
  • 함수 유형을 다른 함수에 전달할 수 있습니다.
  • 다른 함수에서 함수 유형을 반환할 수 있습니다.
  • 람다 표현식은 마지막 표현식의 값을 반환합니다.
  • 매개변수 하나가 포함된 람다 표현식에서 매개변수 라벨이 생략된 경우 람다 표현식은 it 식별자로 참조됩니다.
  • 람다는 변수 이름 없이 인라인으로 작성할 수 있습니다.
  • 함수의 마지막 매개변수가 함수 유형인 경우 후행 람다 문법을 사용하여, 함수를 호출할 때 람다 표현식을 후행 괄호 다음으로 이동할 수 있습니다.
  • 고차 함수는 다른 함수를 매개변수로 사용하거나 함수를 반환하는 함수입니다.
  • repeat() 함수는 for 루프와 비슷하게 작동하는 고차 함수입니다.

자세히 알아보기