이 페이지는 Cloud Translation API를 통해 번역되었습니다.

프로그래머를 위한 Kotlin 부트캠프 3: 함수

이 Codelab은 프로그래머를 위한 Kotlin 부트캠프 과정의 일부입니다. Codelab을 순서대로 진행하면 이 과정의 학습 효과를 극대화할 수 있습니다. 기존 지식에 따라 일부 섹션을 훑어볼 수도 있습니다. 이 과정은 객체 지향 언어를 알고 Kotlin을 배우고 싶은 프로그래머를 대상으로 합니다.

소개

이 Codelab에서는 Kotlin 프로그램을 만들고 매개변수의 기본값, 필터, 람다, 컴팩트 함수를 비롯하여 Kotlin의 함수에 관해 알아봅니다.

이 과정의 강의는 단일 샘플 앱을 빌드하는 대신 지식을 쌓을 수 있도록 설계되었지만, 서로 반독립적이므로 잘 아는 섹션은 대충 훑어볼 수 있습니다. 이러한 요소를 연결하기 위해 많은 예에서 수족관 테마를 사용합니다. 전체 수족관 스토리를 확인하려면 프로그래머를 위한 Kotlin 부트캠프 Udacity 과정을 확인하세요.

기본 요건

최신 객체 지향 정적 형식 지정 프로그래밍 언어의 기본사항
하나 이상의 언어로 클래스, 메서드, 예외 처리를 사용하여 프로그래밍하는 방법
IntelliJ IDEA에서 Kotlin의 REPL (Read-Eval-Print Loop)로 작업하는 방법
유형, 연산자, 루프를 비롯한 Kotlin 기본사항

이 Codelab은 객체 지향 언어를 알고 Kotlin에 대해 자세히 알아보려는 프로그래머를 대상으로 합니다.

학습할 내용

IntelliJ IDEA에서 main() 함수 및 인수를 사용하여 프로그램을 만드는 방법
기본값 및 컴팩트 함수를 사용하는 방법
목록에 필터를 적용하는 방법
기본 람다 및 고차 함수를 만드는 방법

실습할 내용

REPL을 사용하여 코드를 테스트합니다.
IntelliJ IDEA를 사용하여 기본 Kotlin 프로그램을 만듭니다.

이 작업에서는 Kotlin 프로그램을 만들고 main() 함수와 명령줄에서 프로그램에 인수를 전달하는 방법을 알아봅니다.

이전 Codelab에서 REPL에 입력한 printHello() 함수를 기억하실 것입니다.

fun printHello() {
    println ("Hello World")
}

printHello()

⇒ Hello World

fun 키워드와 함수 이름을 사용하여 함수를 정의합니다. 다른 프로그래밍 언어와 마찬가지로 괄호 ()는 함수 인수를 위한 것입니다(있는 경우). 중괄호 {}는 함수의 코드를 프레임으로 지정합니다. 이 함수는 아무것도 반환하지 않으므로 반환 유형이 없습니다.

1단계: Kotlin 파일 만들기

IntelliJ IDEA를 엽니다.
IntelliJ IDEA의 왼쪽 Project 창에는 프로젝트 파일 및 폴더 목록이 표시됩니다. src (이전 Codelab에서 Hello Kotlin 프로젝트가 이미 있어야 합니다.)
New > Kotlin File / Class를 선택합니다.
종류를 파일로 유지하고 파일 이름을 Hello로 지정합니다.
확인을 클릭합니다.

이제 src 폴더에 Hello.kt라는 파일이 있습니다.

2단계: 코드 추가 및 프로그램 실행

다른 언어와 마찬가지로 Kotlin main() 함수는 실행을 위한 진입점을 지정합니다. 명령줄 인수는 문자열 배열로 전달됩니다.

Hello.kt 파일에 다음 코드를 입력하거나 붙여넣습니다.

fun main(args: Array<String>) {
    println("Hello, world!")
}

이 함수에는 이전 printHello() 함수와 마찬가지로 return 문이 없습니다. Kotlin의 모든 함수는 명시적으로 지정되지 않은 경우에도 무언가를 반환합니다. 따라서 이 main() 함수와 같은 함수는 Kotlin에서 값이 없음을 나타내는 kotlin.Unit 유형을 반환합니다.

프로그램을 실행하려면 main() 함수 왼쪽의 녹색 삼각형을 클릭합니다. 메뉴에서 Run 'HelloKt'를 선택합니다.
IntelliJ IDEA가 프로그램을 컴파일하고 실행합니다. 결과는 아래와 같이 하단의 로그 창에 표시됩니다.

3단계: main()에 인수 전달

명령줄이 아닌 IntelliJ IDEA에서 프로그램을 실행하므로 프로그램에 대한 인수를 약간 다르게 지정해야 합니다.

Run > Edit Configurations를 선택합니다. Run/Debug Configurations 창이 열립니다.
프로그램 인수 필드에 Kotlin!을 입력합니다.
확인을 클릭합니다.

4단계: 문자열 템플릿을 사용하도록 코드 변경

문자열 템플릿은 변수 또는 표현식을 문자열에 삽입하고 $는 문자열의 일부가 변수 또는 표현식임을 지정합니다. 중괄호 {}는 표현식을 프레임으로 지정합니다(있는 경우).

Hello.kt에서 인사말 메시지가 "world" 대신 프로그램에 전달된 첫 번째 인수 args[0]를 사용하도록 변경합니다.

fun main(args: Array<String>) {
    println("Hello, ${args[0]}")
}

프로그램을 실행하면 출력에 지정한 인수가 포함됩니다.

⇒ Hello, Kotlin!

이 작업에서는 Kotlin의 거의 모든 항목에 값이 있는 이유와 이것이 유용한 이유를 알아봅니다.

일부 다른 언어에는 값이 없는 코드 줄인 문이 있습니다. Kotlin에서는 거의 모든 것이 표현식이며 값이 있습니다. 값이 kotlin.Unit인 경우에도 마찬가지입니다.

Hello.kt에서 main()에 println()을 isUnit이라는 변수에 할당하고 이를 출력하는 코드를 작성합니다. (println()는 값을 반환하지 않으므로 kotlin.Unit을 반환합니다.)

// Will assign kotlin.Unit
val isUnit = println("This is an expression")
println(isUnit)

프로그램을 실행합니다. 첫 번째 println()는 문자열 "This is an expression"을 출력합니다. 두 번째 println()는 첫 번째 println() 문의 값인 kotlin.Unit를 출력합니다.

⇒ This is an expression
kotlin.Unit

temperature이라는 val을 선언하고 10으로 초기화합니다.
다음 코드와 같이 isHot이라는 다른 val를 선언하고 if/else 문의 반환 값을 isHot에 할당합니다. 표현식이므로 if 표현식의 값을 바로 사용할 수 있습니다.

val temperature = 10
val isHot = if (temperature > 50) true else false
println(isHot)

⇒ false

문자열 템플릿에서 표현식의 값을 사용합니다. 온도를 확인하여 물고기가 안전한지 또는 너무 뜨거운지 확인하는 코드를 추가한 다음 프로그램을 실행합니다.

val temperature = 10
val message = "The water temperature is ${ if (temperature > 50) "too warm" else "OK" }."
println(message)

⇒ The water temperature is OK.

이 작업에서는 Kotlin의 함수와 매우 유용한 when 조건식에 관해 자세히 알아봅니다.

1단계: 함수 만들기

이 단계에서는 학습한 내용을 바탕으로 다양한 유형의 함수를 만듭니다. Hello.kt의 내용을 이 새 코드로 바꿀 수 있습니다.

randomDay()를 호출하여 무작위 요일을 가져오는 feedTheFish()라는 함수를 작성합니다. 문자열 템플릿을 사용하여 물고기가 그날 먹을 food을 출력합니다. 현재 물고기는 매일 같은 음식을 먹습니다.

fun feedTheFish() {
    val day = randomDay()
    val food = "pellets"
    println ("Today is $day and the fish eat $food")
}

fun main(args: Array<String>) {
    feedTheFish()
}

배열에서 임의의 요일을 선택하여 반환하는 randomDay() 함수를 작성합니다.

nextInt() 함수는 week 배열과 일치하도록 Random()부터 0~6까지의 숫자를 제한하는 정수 제한을 사용합니다.

fun randomDay() : String {
    val week = arrayOf ("Monday", "Tuesday", "Wednesday", "Thursday",
            "Friday", "Saturday", "Sunday")
    return week[Random().nextInt(week.size)]
}

Random() 및 nextInt() 함수는 java.util.*에 정의되어 있습니다. 파일 상단에서 필요한 가져오기를 추가합니다.

import java.util.*    // required import

프로그램을 실행하고 출력을 확인합니다.

⇒ Today is Tuesday and the fish eat pellets

2단계: when 표현식 사용

이를 더 확장하여 when 표현식을 사용하여 요일별로 다른 음식을 선택하도록 코드를 변경합니다. when 문은 다른 프로그래밍 언어의 switch와 유사하지만 when는 각 분기 끝에서 자동으로 중단됩니다. 또한 enum을 확인하는 경우 코드가 모든 브랜치를 포함하는지 확인합니다.

Hello.kt에서 요일을 String로 사용하고 해당 요일의 물고기 먹이를 String로 반환하는 fishFood()라는 함수를 추가합니다. when()를 사용하여 매일 물고기에게 특정 먹이를 줍니다. 프로그램을 여러 번 실행하여 다양한 출력을 확인합니다.

fun fishFood (day : String) : String {
    var food = ""
    when (day) {
        "Monday" -> food = "flakes"
        "Tuesday" -> food = "pellets"
        "Wednesday" -> food = "redworms"
        "Thursday" -> food = "granules"
        "Friday" -> food = "mosquitoes"
        "Saturday" -> food = "lettuce"
        "Sunday" -> food = "plankton"
    }
    return food
}

fun feedTheFish() {
    val day = randomDay()
    val food = fishFood(day)

    println ("Today is $day and the fish eat $food")
}

⇒ Today is Thursday and the fish eat granules

else을 사용하여 when 표현식에 기본 브랜치를 추가합니다. 테스트를 위해 프로그램에서 기본값이 사용되는지 확인하려면 Tuesday 및 Saturday 브랜치를 삭제하세요.

기본 브랜치가 있으면 food이 반환되기 전에 값을 가져오므로 더 이상 초기화할 필요가 없습니다. 이제 코드가 문자열을 food에 한 번만 할당하므로 var 대신 val로 food를 선언할 수 있습니다.

fun fishFood (day : String) : String {
    val food : String
    when (day) {
        "Monday" -> food = "flakes"
        "Wednesday" -> food = "redworms"
        "Thursday" -> food = "granules"
        "Friday" -> food = "mosquitoes"
        "Sunday" -> food = "plankton"
        else -> food = "nothing"
    }
    return food
}

모든 표현식에는 값이 있으므로 이 코드를 좀 더 간결하게 만들 수 있습니다. when 표현식의 값을 직접 반환하고 food 변수를 삭제합니다. when 표현식의 값은 조건을 충족한 분기의 마지막 표현식의 값입니다.

fun fishFood (day : String) : String {
    return when (day) {
        "Monday" -> "flakes"
        "Wednesday" -> "redworms"
        "Thursday" -> "granules"
        "Friday" -> "mosquitoes"
        "Sunday" -> "plankton"
        else -> "nothing"
    }
}

프로그램의 최종 버전은 아래 코드와 같습니다.

import java.util.*    // required import

fun randomDay() : String {
    val week = arrayOf ("Monday", "Tuesday", "Wednesday", "Thursday",
        "Friday", "Saturday", "Sunday")
    return week[Random().nextInt(week.size)]
}

fun fishFood (day : String) : String {
    return when (day) {
        "Monday" -> "flakes"
        "Wednesday" -> "redworms"
        "Thursday" -> "granules"
        "Friday" -> "mosquitoes"
        "Sunday" -> "plankton"
        else -> "nothing"
    }
}

fun feedTheFish() {
    val day = randomDay()
    val food = fishFood(day)
    println ("Today is $day and the fish eat $food")
}

fun main(args: Array<String>) {
    feedTheFish()
}

이 작업에서는 함수와 메서드의 기본값에 대해 알아봅니다. 또한 코드를 더 간결하고 읽기 쉽게 만들고 테스트를 위한 코드 경로 수를 줄일 수 있는 간결한 함수에 대해서도 알아봅니다. 간결한 함수를 단일 표현식 함수라고도 합니다.

1단계: 매개변수의 기본값 만들기

Kotlin에서는 매개변수 이름으로 인수를 전달할 수 있습니다. 매개변수의 기본값을 지정할 수도 있습니다. 호출자가 인수를 제공하지 않으면 기본값이 사용됩니다. 나중에 메서드 (멤버 함수)를 작성할 때 동일한 메서드의 오버로드 버전을 많이 작성하지 않아도 됩니다.

Hello.kt에서 물고기의 속도를 출력하는 speed라는 이름의 String 매개변수가 있는 swim() 함수를 작성합니다. speed 매개변수의 기본값은 "fast"입니다.

fun swim(speed: String = "fast") {
   println("swimming $speed")
}

main() 함수에서 swim() 함수를 세 가지 방법으로 호출합니다. 먼저 기본값을 사용하여 함수를 호출합니다. 그런 다음 함수를 호출하고 이름 없이 speed 매개변수를 전달한 다음 speed 매개변수의 이름을 지정하여 함수를 호출합니다.

swim()   // uses default speed
swim("slow")   // positional argument
swim(speed="turtle-like")   // named parameter

⇒ swimming fast
swimming slow
swimming turtle-like

2단계: 필수 매개변수 추가

매개변수에 기본값이 지정되지 않은 경우 해당 인수는 항상 전달되어야 합니다.

Hello.kt에서 세 가지 매개변수(day, temperature, dirty 수준)를 사용하는 shouldChangeWater() 함수를 작성합니다. 물이 너무 더럽거나, 온도가 너무 높거나, 일요일인 경우 물을 바꿔야 하므로 함수는 true을 반환합니다. 요일은 필수이지만 기본 온도는 22이고 기본 오염도는 20입니다.

인수가 없는 when 표현식을 사용하세요. Kotlin에서는 if/else if 검사 시리즈로 작동합니다.

fun shouldChangeWater (day: String, temperature: Int = 22, dirty: Int = 20): Boolean {
    return when {
        temperature > 30 -> true
        dirty > 30 -> true
        day == "Sunday" ->  true
        else -> false
    }
}

feedTheFish()에서 shouldChangeWater()를 호출하고 요일을 제공합니다. day 매개변수에는 기본값이 없으므로 인수를 지정해야 합니다. shouldChangeWater()의 다른 두 매개변수에는 기본값이 있으므로 인수를 전달하지 않아도 됩니다.

fun feedTheFish() {
    val day = randomDay()
    val food = fishFood(day)
    println ("Today is $day and the fish eat $food")
    println("Change water: ${shouldChangeWater(day)}")
}

=> Today is Thursday and the fish eat granules
Change water: false

3단계: 간결한 함수 만들기

이전 단계에서 작성한 when 표현식은 적은 양의 코드에 많은 로직을 포함합니다. 약간의 압축 해제가 필요하거나 확인해야 하는 조건이 더 복잡한 경우 이름이 잘 지정된 로컬 변수를 사용할 수 있습니다. 하지만 Kotlin에서는 컴팩트 함수를 사용하여 이를 수행합니다.

간결한 함수 또는 단일 표현식 함수는 Kotlin에서 일반적인 패턴입니다. 함수가 단일 표현식의 결과를 반환하는 경우 = 기호 뒤에 함수의 본문을 지정하고 중괄호 {}를 생략하고 return를 생략할 수 있습니다.

Hello.kt에서 조건을 테스트하는 소형 함수를 추가합니다.

fun isTooHot(temperature: Int) = temperature > 30

fun isDirty(dirty: Int) = dirty > 30

fun isSunday(day: String) = day == "Sunday"

새 함수를 호출하도록 shouldChangeWater()을 변경합니다.

fun shouldChangeWater (day: String, temperature: Int = 22, dirty: Int = 20): Boolean {
    return when {
        isTooHot(temperature) -> true
        isDirty(dirty) -> true
        isSunday(day) -> true
        else  -> false
    }
}

프로그램을 실행합니다. shouldChangeWater()를 사용하는 println()의 출력은 컴팩트 함수를 사용하도록 전환하기 전과 동일해야 합니다.

기본값

매개변수의 기본값은 값이 아니어도 됩니다. 다음 부분 샘플과 같이 다른 함수일 수도 있습니다.

fun shouldChangeWater (day: String, temperature: Int = 22, dirty: Int = getDirtySensorReading()): Boolean {
    ...

이 작업에서는 Kotlin의 필터에 관해 간략하게 알아봅니다. 필터는 특정 조건을 기반으로 목록의 일부를 가져오는 편리한 방법입니다.

1단계: 필터 만들기

Hello.kt에서 listOf()를 사용하여 최상위 수준에 수족관 장식 목록을 정의합니다. Hello.kt의 내용을 바꿀 수 있습니다.

val decorations = listOf ("rock", "pagoda", "plastic plant", "alligator", "flowerpot")

'p'로 시작하는 장식만 출력하는 줄이 있는 새 main() 함수를 만듭니다. 필터 조건의 코드는 중괄호 {} 안에 있으며, it는 필터가 반복될 때 각 항목을 참조합니다. 표현식이 true을 반환하면 항목이 포함됩니다.

fun main() {
    println( decorations.filter {it[0] == 'p'})
}

프로그램을 실행하면 실행 창에 다음 출력이 표시됩니다.

⇒ [pagoda, plastic plant]

2단계: eager 필터와 lazy 필터 비교

다른 언어의 필터에 익숙하다면 Kotlin의 필터가 즉시 실행인지 지연 실행인지 궁금할 수 있습니다. 결과 목록은 즉시 생성되나요, 아니면 목록에 액세스할 때 생성되나요? Kotlin에서는 원하는 방식으로 발생합니다. 기본적으로 filter는 eager이며 필터를 사용할 때마다 목록이 생성됩니다.

필터를 지연하려면 시작부터 끝까지 한 번에 하나의 항목만 볼 수 있는 컬렉션인 Sequence를 사용하면 됩니다. 편리하게도 이는 지연 필터에 필요한 API와 정확히 일치합니다.

Hello.kt에서 필터링된 목록을 eager라는 변수에 할당한 후 출력하도록 코드를 변경합니다.

fun main() {
    val decorations = listOf ("rock", "pagoda", "plastic plant", "alligator", "flowerpot")

    // eager, creates a new list
    val eager = decorations.filter { it [0] == 'p' }
    println("eager: " + eager)

해당 코드 아래에서 asSequence()이 있는 Sequence를 사용하여 필터를 평가합니다. 시퀀스를 filtered이라는 변수에 할당하고 출력합니다.

   // lazy, will wait until asked to evaluate
    val filtered = decorations.asSequence().filter { it[0] == 'p' }
    println("filtered: " + filtered)

필터 결과를 Sequence로 반환하면 filtered 변수는 새 목록을 보유하지 않습니다. 목록 요소의 Sequence와 이러한 요소에 적용할 필터에 관한 지식을 보유합니다. Sequence의 요소에 액세스할 때마다 필터가 적용되고 결과가 반환됩니다.

toList()을 사용하여 시퀀스를 List으로 변환하여 시퀀스를 강제로 평가합니다. 결과를 출력합니다.

    // force evaluation of the lazy list
    val newList = filtered.toList()
    println("new list: " + newList)

프로그램을 실행하고 출력을 살펴봅니다.

⇒ eager: [pagoda, plastic plant]
filtered: kotlin.sequences.FilteringSequence@386cc1c4
new list: [pagoda, plastic plant]

Sequence 및 지연 평가의 작동 방식을 시각화하려면 map() 함수를 사용하세요. map() 함수는 시퀀스의 각 요소에 간단한 변환을 실행합니다.

위와 동일한 decorations 목록을 사용하여 아무 작업도 하지 않고 전달된 요소를 간단히 반환하는 map()로 변환합니다. 요소에 액세스할 때마다 표시되도록 println()를 추가하고 시퀀스를 lazyMap이라는 변수에 할당합니다.

    val lazyMap = decorations.asSequence().map {
        println("access: $it")
        it
    }

lazyMap를 출력하고, first()을 사용하여 lazyMap의 첫 번째 요소를 출력하고, List로 변환된 lazyMap를 출력합니다.

    println("lazy: $lazyMap")
    println("-----")
    println("first: ${lazyMap.first()}")
    println("-----")
    println("all: ${lazyMap.toList()}")

프로그램을 실행하고 출력을 살펴봅니다. lazyMap를 출력하면 Sequence에 대한 참조만 출력되고 내부 println()는 호출되지 않습니다. 첫 번째 요소를 인쇄하면 첫 번째 요소만 액세스합니다. Sequence을 List로 변환하면 모든 요소에 액세스할 수 있습니다.

⇒ lazy: kotlin.sequences.TransformingSequence@5ba23b66
-----
access: rock
first: rock
-----
access: rock
access: pagoda
access: plastic plant
access: alligator
access: flowerpot
all: [rock, pagoda, plastic plant, alligator, flowerpot]

map를 적용하기 전에 원래 필터를 사용하여 새 Sequence를 만듭니다. 결과를 출력합니다.

    val lazyMap2 = decorations.asSequence().filter {it[0] == 'p'}.map {
        println("access: $it")
        it
    }
    println("-----")
    println("filtered: ${ lazyMap2.toList() }")

프로그램을 실행하고 추가 출력을 살펴봅니다. 첫 번째 요소를 가져오는 것과 마찬가지로 내부 println()는 액세스된 요소에 대해서만 호출됩니다.

⇒
-----
access: pagoda
access: plastic plant
filtered: [pagoda, plastic plant]

이 작업에서는 Kotlin의 람다 및 고차 함수를 소개합니다.

람다

Kotlin은 기존의 이름이 지정된 함수 외에도 람다를 지원합니다. 람다는 함수를 만드는 표현식입니다. 하지만 이름이 지정된 함수를 선언하는 대신 이름이 없는 함수를 선언합니다. 이 기능이 유용한 이유는 이제 람다 표현식을 데이터로 전달할 수 있기 때문입니다. 다른 언어에서는 람다를 익명 함수, 함수 리터럴 또는 이와 유사한 이름으로 부릅니다.

고차 함수

람다를 다른 함수에 전달하여 고차 함수를 만들 수 있습니다. 이전 작업에서는 filter이라는 고차 함수를 만들었습니다. 다음 람다 표현식을 filter에 검사할 조건으로 전달했습니다.
{it[0] == 'p'}

마찬가지로 map는 고차 함수이며 여기에 전달한 람다는 적용할 변환입니다.

1단계: 람다 알아보기

이름이 지정된 함수와 마찬가지로 람다에는 매개변수가 있을 수 있습니다. 람다의 경우 매개변수 (및 필요한 경우 유형)는 함수 화살표 ->의 왼쪽에 있습니다. 실행할 코드는 함수 화살표 오른쪽에 있습니다. 람다가 변수에 할당되면 함수처럼 호출할 수 있습니다.

REPL (도구 > Kotlin > Kotlin REPL)을 사용하여 다음 코드를 사용해 보세요.

var dirtyLevel = 20
val waterFilter = { dirty : Int -> dirty / 2}
println(waterFilter(dirtyLevel))

⇒ 10

이 예시에서 람다는 dirty이라는 Int를 가져와 dirty / 2를 반환합니다. (필터링을 통해 먼지가 제거되기 때문입니다.)

함수 유형에 관한 Kotlin의 문법은 람다에 관한 문법과 밀접한 관련이 있습니다. 함수를 보유하는 변수를 명확하게 선언하려면 다음 문법을 사용하세요.

val waterFilter: (Int) -> Int = { dirty -> dirty / 2 }

코드의 내용은 다음과 같습니다.

waterFilter이라는 변수를 만듭니다.
waterFilter는 Int을 사용하고 Int을 반환하는 함수일 수 있습니다.
waterFilter에 람다를 할당합니다.
람다는 인수 dirty를 2로 나눈 값을 반환합니다.

더 이상 람다 인수의 유형을 지정하지 않아도 됩니다. 유형은 유형 추론에 의해 계산됩니다.

2단계: 고차 함수 만들기

지금까지 람다 예시는 대부분 함수와 비슷해 보였습니다. 람다의 진정한 힘은 람다를 사용하여 고차 함수를 만드는 데 있습니다. 고차 함수에서는 한 함수의 인수가 다른 함수입니다.

고차 함수를 작성합니다. 다음은 두 개의 인수를 사용하는 함수의 기본 예입니다. 첫 번째 인수는 정수입니다. 두 번째 인수는 정수를 사용하고 정수를 반환하는 함수입니다. REPL에서 사용해 보세요.

fun updateDirty(dirty: Int, operation: (Int) -> Int): Int {
   return operation(dirty)
}

코드 본문은 두 번째 인수로 전달된 함수를 호출하고 첫 번째 인수를 전달합니다.

이 함수를 호출하려면 정수와 함수를 전달하세요.

val waterFilter: (Int) -> Int = { dirty -> dirty / 2 }
println(updateDirty(30, waterFilter))

⇒ 15

전달하는 함수가 람다가 아니어도 됩니다. 대신 일반적인 이름이 지정된 함수여도 됩니다. 인수를 일반 함수로 지정하려면 :: 연산자를 사용합니다. 이렇게 하면 Kotlin에서 함수를 호출하는 것이 아니라 함수 참조를 인수로 전달하고 있음을 알 수 있습니다.

일반 이름이 지정된 함수를 updateDirty()에 전달해 보세요.

fun increaseDirty( start: Int ) = start + 1

println(updateDirty(15, ::increaseDirty))

⇒ 16

var dirtyLevel = 19;
dirtyLevel = updateDirty(dirtyLevel) { dirtyLevel -> dirtyLevel + 23}
println(dirtyLevel)

⇒ 42

IntelliJ IDEA에서 Kotlin 소스 파일을 만들려면 Kotlin 프로젝트로 시작하세요.
IntelliJ IDEA에서 프로그램을 컴파일하고 실행하려면 main() 함수 옆에 있는 녹색 삼각형을 클릭합니다. 출력은 아래 로그 창에 표시됩니다.
IntelliJ IDEA에서 Run > Edit Configurations에서 main() 함수에 전달할 명령줄 인수를 지정합니다.
Kotlin의 거의 모든 항목에는 값이 있습니다. 이 사실을 사용하여 if 또는 when 값을 표현식 또는 반환 값으로 사용하여 코드를 더 간결하게 만들 수 있습니다.
기본 인수를 사용하면 함수나 메서드의 여러 버전이 필요하지 않습니다. 예를 들면 다음과 같습니다.
fun swim(speed: String = "fast") { ... }
간결한 함수 또는 단일 표현식 함수를 사용하면 코드를 더 쉽게 읽을 수 있습니다. 예를 들면 다음과 같습니다.
fun isTooHot(temperature: Int) = temperature > 30
람다 표현식을 사용하는 필터에 관한 몇 가지 기본사항을 알아봤습니다. 예를 들면 다음과 같습니다.
val beginsWithP = decorations.filter { it [0] == 'p' }
람다 표현식은 이름이 없는 함수를 만드는 표현식입니다. 람다 표현식은 중괄호 {} 사이에 정의됩니다.
고차 함수에서는 람다 표현식과 같은 함수를 다른 함수에 데이터로 전달합니다. 예:
dirtyLevel = updateDirty(dirtyLevel) { dirtyLevel -> dirtyLevel + 23}

특히 람다를 처음 접하는 경우 이 강의에 많은 내용이 포함되어 있습니다. 나중에 람다와 고차 함수를 다시 살펴봅니다.

Kotlin 문서

이 과정의 주제에 관해 자세히 알아보거나 막히는 부분이 있다면 https://kotlinlang.org에서 시작하는 것이 좋습니다.

Kotlin 튜토리얼

https://try.kotlinlang.org 웹사이트에는 Kotlin Koans라는 풍부한 튜토리얼, 웹 기반 인터프리터, 예시가 포함된 전체 참고 문서 세트가 포함되어 있습니다.

Udacity 과정

이 주제에 관한 Udacity 과정을 보려면 프로그래머를 위한 Kotlin 부트캠프를 참고하세요.

IntelliJ IDEA

IntelliJ IDEA 문서는 JetBrains 웹사이트에서 확인할 수 있습니다.

이 섹션에는 강사가 진행하는 과정의 일부로 이 Codelab을 진행하는 학생에게 출제할 수 있는 과제가 나열되어 있습니다. 다음 작업은 강사가 결정합니다.

필요한 경우 과제를 할당합니다.
과제 제출 방법을 학생에게 알립니다.
과제를 채점합니다.

강사는 이러한 추천을 원하는 만큼 사용할 수 있으며 적절하다고 생각되는 다른 과제를 출제해도 됩니다.

이 Codelab을 직접 진행하는 경우 이러한 과제를 자유롭게 사용하여 배운 내용을 테스트해 보세요.

질문에 답하세요

질문 1

contains(element: String) 함수는 문자열 element가 호출된 문자열에 포함된 경우 true을 반환합니다. 다음 코드의 출력은 무엇인가요?

val decorations = listOf ("rock", "pagoda", "plastic plant", "alligator", "flowerpot")

println(decorations.filter {it.contains('p')})

▢ [pagoda, plastic, plant]

▢ [pagoda, plastic plant]

▢ [pagoda, plastic plant, flowerpot]

▢ [rock, alligator]

질문 2

다음 함수 정의에서 필수 매개변수는 무엇인가요?
fun shouldChangeWater (day: String, temperature: Int = 22, dirty: Int = 20, numDecorations: Int = 0): Boolean {...}

▢ numDecorations

▢ dirty

▢ day

▢ temperature

질문 3

일반 이름이 지정된 함수 (호출 결과가 아님)를 다른 함수에 전달할 수 있습니다. increaseDirty( start: Int ) = start + 1을 updateDirty(dirty: Int, operation: (Int) -> Int)에 어떻게 전달하겠어?

▢ updateDirty(15, &increaseDirty())

▢ updateDirty(15, increaseDirty())

▢ updateDirty(15, ("increaseDirty()"))

▢ updateDirty(15, ::increaseDirty)

다음 강의로 진행합니다. 4. 클래스와 객체

다른 Codelab 링크를 비롯한 과정 개요는 프로그래머를 위한 Kotlin 부트캠프: 과정에 오신 것을 환영합니다를 참고하세요.