Kotlin Bootcamp for Programmers 3: Fungsi

Codelab ini adalah bagian dari kursus Kotlin Bootcamp for Programmers. Anda akan mendapatkan manfaat maksimal dari kursus ini jika menyelesaikan codelab secara berurutan. Anda mungkin dapat membaca cepat beberapa bagian, bergantung pada pengetahuan Anda. Kursus ini ditujukan bagi programer yang menguasai bahasa berorientasi objek, dan ingin mempelajari Kotlin.

Pengantar

Dalam codelab ini, Anda akan membuat program Kotlin dan mempelajari fungsi di Kotlin, termasuk nilai default untuk parameter, filter, lambda, dan fungsi ringkas.

Daripada membuat satu aplikasi contoh, pelajaran dalam kursus ini dirancang untuk membangun pengetahuan Anda, tetapi bersifat semi-independen satu sama lain sehingga Anda dapat membaca sekilas bagian yang sudah Anda kuasai. Untuk mengaitkannya, banyak contoh yang menggunakan tema akuarium. Jika Anda ingin melihat kisah akuarium selengkapnya, lihat kursus Kotlin Bootcamp for Programmers di Udacity.

Yang harus sudah Anda ketahui

• Dasar-dasar bahasa pemrograman modern, berorientasi objek, berjenis statis
• Cara memprogram dengan class, metode, dan penanganan pengecualian dalam setidaknya satu bahasa
• Cara menggunakan REPL (Read-Eval-Print Loop) Kotlin di IntelliJ IDEA
• Dasar-dasar Kotlin, termasuk jenis, operator, dan loop

Codelab ini ditujukan bagi programmer yang menguasai bahasa berorientasi objek dan ingin mempelajari lebih lanjut Kotlin.

Yang akan Anda pelajari

• Cara membuat program dengan fungsi main() dan argumen di IntelliJ IDEA
• Cara menggunakan nilai default dan fungsi ringkas
• Cara menerapkan filter untuk daftar
• Cara membuat lambda dasar dan fungsi urutan yang lebih tinggi

Yang akan Anda lakukan

• Bekerja dengan REPL untuk mencoba beberapa kode.
• Bekerja dengan IntelliJ IDEA untuk membuat program Kotlin dasar.

Dalam tugas ini, Anda akan membuat program Kotlin dan mempelajari fungsi main(), serta cara meneruskan argumen ke program dari command line.

Anda mungkin ingat fungsi printHello() yang Anda masukkan ke REPL di codelab sebelumnya:

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

printHello()

⇒ Hello World

Anda menentukan fungsi menggunakan kata kunci fun, diikuti dengan nama fungsi tersebut. Seperti bahasa pemrograman lainnya, tanda kurung () diperuntukkan sebagai argumen fungsi, jika ada. Kurung kurawal {} membingkai kode untuk fungsi tersebut. Tidak ada jenis nilai yang ditampilkan untuk fungsi ini, karena fungsi ini tidak menampilkan apa pun.

Langkah 1: Buat file Kotlin

1. Buka IntelliJ IDEA.
2. Panel Project di sebelah kiri di IntelliJ IDEA menampilkan daftar file dan folder project Anda. Temukan dan klik kanan folder src di bagian Hello Kotlin. (Anda seharusnya sudah memiliki project Hello Kotlin dari codelab sebelumnya.)
3. Pilih New > Kotlin File / Class.
4. Tetapkan Kind sebagai File, dan beri nama file Hello.
5. Klik Oke.

Sekarang ada file di folder src yang disebut Hello.kt.

Langkah 2: Tambahkan kode dan jalankan program Anda

1. Seperti bahasa lainnya, fungsi main() Kotlin menentukan titik entri untuk eksekusi. Argumen command line apa pun diteruskan sebagai array string.
   
   Ketik atau tempel kode berikut ke dalam file Hello.kt :

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

Tips: Mulai Kotlin 1.3, jika fungsi main() Anda tidak menggunakan parameter apa pun, Anda tidak perlu menentukan args.

Seperti fungsi printHello() sebelumnya, fungsi ini tidak memiliki pernyataan return. Fungsi apa pun dalam Kotlin me-return sesuatu, bahkan ketika tidak ada apa pun ditentukan secara eksplisit. Jadi, fungsi seperti fungsi main() ini akan menampilkan jenis kotlin.Unit, yang merupakan cara Kotlin untuk menyatakan tidak ada nilai.

Catatan: Saat fungsi menampilkan kotlin.Unit, Anda tidak perlu menentukannya secara eksplisit. Hal ini berlainan dari beberapa bahasa, yang mengharuskan Anda menyatakan secara eksplisit bahwa Anda tidak me-return apa pun.

3. Untuk menjalankan program, klik segitiga hijau di sebelah kiri fungsi main(). Pilih Run 'HelloKt' dari menu.
4. IntelliJ IDEA mengompilasi program dan menjalankannya. Hasilnya akan muncul di panel log di bagian bawah, seperti yang ditunjukkan di bawah.

Pemrogram Java: Jika Anda menggunakan IntelliJ IDEA versi yang telah diinstal sebelumnya, bukan menginstal salinan baru, pada tahap ini Anda mungkin mengalami masalah saat mengakses compiler Kotlin. Pastikan project Anda merujuk ke versi JDK yang benar. Lihat diskusi ini di Stack Overflow dan dokumentasi Mengubah SDK project untuk IntelliJ IDEA.

Langkah 3: Teruskan argumen ke main()

Karena Anda menjalankan program dari IntelliJ IDEA dan bukan dari command line, Anda perlu sedikit berbeda dalam menentukan argumen apa pun untuk program.

1. Pilih Run > Edit Configurations. Jendela Run/Debug Configurations akan terbuka.
2. Ketik Kotlin! di kolom Program arguments.
3. Klik Oke.

Langkah 4: Ubah kode untuk menggunakan template string

Template string menyisipkan variabel atau ekspresi ke dalam string, dan $ menentukan bahwa bagian string tersebut akan menjadi variabel atau ekspresi. Kurung kurawal {} membingkai ekspresi, jika ada.

1. Dalam Hello.kt, ubah pesan sambutan untuk menggunakan argumen pertama yang diteruskan ke program, args[0], bukan "world".

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

2. Jalankan program, dan output-nya akan menyertakan argumen yang Anda tentukan.

⇒ Hello, Kotlin!

Dalam tugas ini, Anda akan mempelajari alasan hampir semua hal di Kotlin memiliki nilai, dan alasan hal itu berguna.

Beberapa bahasa lainnya memiliki pernyataan, yang merupakan baris kode yang tidak memiliki nilai. Di Kotlin, hampir setiap hal adalah ekspresi dan memiliki nilai—meskipun nilai tersebut adalah kotlin.Unit.

1. Di Hello.kt, tulis kode di main() untuk menetapkan println() ke variabel yang disebut isUnit, lalu cetak. (println() tidak menampilkan nilai, jadi yang ditampilkan adalah kotlin.Unit.)

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

2. Jalankan program Anda. println() pertama mencetak string "This is an expression". println() kedua mencetak nilai pernyataan println() pertama, yaitu kotlin.Unit.

⇒ This is an expression
kotlin.Unit

3. Deklarasikan val yang disebut temperature dan lakukan inisialisasi ke 10.
4. Deklarasikan val lain yang disebut isHot dan tetapkan nilai yang ditampilkan dari pernyataan if/else ke isHot, seperti yang ditunjukkan dalam kode berikut. Karena merupakan ekspresi, Anda dapat langsung menggunakan nilai ekspresi if.

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

⇒ false

4. Gunakan nilai ekspresi dalam template string. Tambahkan beberapa kode untuk memeriksa suhu guna menentukan apakah ikan aman atau terlalu hangat, lalu jalankan program Anda.

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

⇒ The water temperature is OK.

Catatan: Loop merupakan pengecualian untuk "segala sesuatu yang memiliki nilai." Tidak ada nilai yang logis untuk loop for atau loop while, sehingga Loop tidak memiliki nilai. Jika Anda mencoba menetapkan nilai loop ke sesuatu, compiler akan menampilkan error.

Dalam tugas ini, Anda akan mempelajari lebih lanjut fungsi di Kotlin, dan lebih lanjut tentang ekspresi kondisional when yang sangat berguna.

Langkah 1: Buat beberapa fungsi

Pada langkah ini, Anda menggabungkan beberapa hal yang telah Anda pelajari dan membuat fungsi dengan berbagai jenis. Anda dapat mengganti konten Hello.kt dengan kode baru ini.

1. Tulis fungsi bernama feedTheFish() yang memanggil randomDay() untuk mendapatkan hari dalam seminggu secara acak. Gunakan template string untuk mencetak food yang akan dimakan ikan pada hari itu. Untuk saat ini, ikan-ikan tersebut memakan makanan yang sama setiap hari.

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

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

2. Tulis fungsi randomDay() untuk memilih hari acak dari array dan menampilkannya.

Fungsi nextInt() mengambil batas bilangan bulat, yang membatasi angka dari Random() hingga 0 melalui 6 agar cocok dengan array week.

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

3. Fungsi Random() dan nextInt() ditentukan di java.util.*. Di bagian atas file, tambahkan impor yang diperlukan:

import java.util.*    // required import

Tips: Sebelum Anda menambahkan impor, Random() memberikan error referensi yang belum terselesaikan di IntelliJ IDEA. Untuk menambahkan impor secara otomatis, klik Random(), lalu tekan Alt+Enter (Option+Enter di Mac). Pilih Import > java.util.Random.

4. Jalankan program Anda, dan periksa output-nya.

⇒ Today is Tuesday and the fish eat pellets

Langkah 2: Menggunakan ekspresi when

Untuk memperluasnya, ubah kode untuk memilih makanan yang berbeda untuk hari yang berbeda menggunakan ekspresi when. Pernyataan when mirip dengan switch dalam bahasa pemrograman lain, tetapi when otomatis berhenti di akhir setiap cabang. Fitur ini juga memastikan kode Anda mencakup semua cabang jika Anda memeriksa enum.

1. Di Hello.kt, tambahkan fungsi bernama fishFood() yang menggunakan hari sebagai String dan menampilkan makanan ikan untuk hari itu sebagai String. Gunakan when(), sehingga setiap hari ikan mendapatkan makanan tertentu. Jalankan program Anda beberapa kali untuk melihat output yang berbeda.

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

2. Tambahkan cabang default ke ekspresi when menggunakan else. Untuk pengujian, guna memastikan default terkadang diambil dalam program Anda, hapus cabang Tuesday dan Saturday.
   
   Dengan memiliki cabang default, food akan mendapatkan nilai sebelum ditampilkan, sehingga tidak perlu diinisialisasi lagi. Karena kode sekarang hanya menetapkan string ke food satu kali, Anda dapat mendeklarasikan food dengan val, bukan var.

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
}

3. Karena setiap ekspresi memiliki nilai, Anda dapat membuat kode ini sedikit lebih ringkas. Tampilkan nilai ekspresi when secara langsung, dan hapus variabel food. Nilai ekspresi when adalah nilai ekspresi terakhir dari cabang yang memenuhi kondisi.

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

Versi akhir program Anda akan terlihat seperti kode di bawah.

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()
}

Dalam tugas ini, Anda akan mempelajari nilai default untuk fungsi dan metode. Anda juga akan mempelajari fungsi ringkas, yang dapat membuat kode Anda lebih ringkas dan mudah dibaca, serta dapat mengurangi jumlah jalur kode untuk pengujian. Fungsi ringkas juga disebut fungsi ekspresi tunggal.

Langkah 1: Buat nilai default untuk parameter

Di Kotlin, Anda dapat meneruskan argumen berdasarkan nama parameter. Anda juga dapat menentukan nilai default untuk parameter: jika argumen tidak diberikan oleh pemanggil, nilai default akan digunakan. Selanjutnya, saat Anda menulis metode (fungsi anggota), berarti Anda dapat menghindari penulisan banyak versi overload dari metode yang sama.

1. Di Hello.kt, tulis fungsi swim() dengan parameter String bernama speed yang mencetak kecepatan ikan. Parameter speed memiliki nilai default "fast".

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

2. Dari fungsi main(), panggil fungsi swim() menggunakan tiga cara. Pertama, panggil fungsi menggunakan default. Kemudian, panggil fungsi dan teruskan parameter speed tanpa nama, lalu panggil fungsi dengan menamai parameter speed.

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

⇒ swimming fast
swimming slow
swimming turtle-like

Catatan: Argumen tidak harus menggunakan nama parameter; Anda cukup meneruskan argumen dalam urutan yang ditentukan. Namun, dengan nilai default, hal ini bisa sedikit membingungkan, jadi sebaiknya letakkan parameter tanpa default terlebih dahulu, dan parameter dengan default setelahnya.

Langkah 2: Tambahkan parameter wajib

Jika tidak ada nilai default yang ditentukan untuk sebuah parameter, argumen yang sesuai harus selalu diteruskan.

1. Di Hello.kt, tulis fungsi shouldChangeWater() yang menggunakan tiga parameter: day, temperature, dan tingkat dirty. Fungsi ini menampilkan true jika air harus diganti, yang terjadi jika hari Minggu, jika suhu terlalu tinggi, atau jika air terlalu kotor. Hari dalam seminggu diperlukan, tetapi suhu defaultnya adalah 22, dan tingkat kotor defaultnya adalah 20.
   
   Gunakan ekspresi when tanpa argumen, yang di Kotlin berfungsi sebagai serangkaian pemeriksaan 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
    }
}

2. Panggil shouldChangeWater() dari feedTheFish() dan berikan hari. Parameter day tidak memiliki nilai default, jadi Anda harus menentukan argumen. Dua parameter shouldChangeWater() lainnya memiliki nilai default, jadi Anda tidak perlu meneruskan argumen untuknya.
   

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

Langkah 3: Buat fungsi rapat

Ekspresi when yang Anda tulis pada langkah sebelumnya mengemas banyak logika ke dalam sedikit kode. Jika ingin menguraikannya sedikit, atau jika kondisi yang perlu diperiksa lebih rumit, Anda dapat menggunakan beberapa variabel lokal yang diberi nama dengan baik. Namun, cara Kotlin untuk melakukannya adalah dengan fungsi ringkas.

Fungsi ringkas, atau fungsi ekspresi tunggal, adalah pola umum di Kotlin. Jika fungsi menampilkan hasil ekspresi tunggal, Anda dapat menentukan isi fungsi setelah simbol =, menghilangkan tanda kurung kurawal {}, dan menghilangkan return.

1. di Hello.kt, tambahkan fungsi ringkas untuk menguji kondisi.

fun isTooHot(temperature: Int) = temperature > 30

fun isDirty(dirty: Int) = dirty > 30

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

2. Ubah shouldChangeWater() untuk memanggil fungsi baru.

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

3. Jalankan program Anda. Output dari println() dengan shouldChangeWater() harus sama seperti sebelum Anda beralih menggunakan fungsi ringkas.

Nilai default

Nilai default untuk parameter tidak harus berupa nilai. Dapat berupa fungsi lain, seperti yang ditunjukkan dalam contoh sebagian berikut:

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

Catatan: Fungsi yang digunakan sebagai nilai default dievaluasi saat runtime, jadi jangan menempatkan operasi yang mahal seperti pembacaan file atau alokasi memori besar dalam fungsi. Operasi dijalankan setiap kali fungsi Anda dipanggil, yang dapat memperlambat program Anda.

Dalam tugas ini, Anda akan mempelajari sedikit tentang filter di Kotlin. Filter adalah cara praktis untuk mengambil bagian dari daftar berdasarkan sejumlah kondisi.

Langkah 1: Buat filter

1. Di Hello.kt, tentukan daftar dekorasi akuarium di level teratas dengan listOf(). Anda dapat mengganti konten Hello.kt.

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

2. Buat fungsi main() baru dengan baris untuk mencetak hanya dekorasi yang dimulai dengan huruf 'p'. Kode untuk kondisi filter berada dalam tanda kurung kurawal {}, dan it merujuk ke setiap item saat filter diproses. Jika ekspresi menampilkan true, item disertakan.

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

3. Jalankan program Anda, dan Anda akan melihat output berikut di jendela Run:

⇒ [pagoda, plastic plant]

Langkah 2: Bandingkan filter cepat dan lambat

Jika Anda sudah terbiasa dengan filter dalam bahasa lain, Anda mungkin bertanya-tanya apakah filter di Kotlin bersifat eager atau lazy. Apakah daftar hasil dibuat dengan segera, atau saat daftar diakses? Di Kotlin, hal ini terjadi dengan cara apa pun yang Anda butuhkan. Secara default, filter sudah dalam setelan cepat, dan setiap kali Anda menggunakan filter, sebuah daftar langsung dibuat.

Untuk membuat filter yang lambat, Anda dapat menggunakan Sequence, yang merupakan koleksi yang dapat menampilkan hanya satu item sekaligus, dimulai dari awal hingga akhir. Ringkasnya, inilah API yang dibutuhkan oleh filter lambat.

1. Di Hello.kt, ubah kode Anda untuk menetapkan daftar yang difilter ke variabel bernama eager, lalu cetak.

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)

2. Di bawah kode tersebut, evaluasi filter menggunakan Sequence dengan asSequence(). Menetapkan urutan ke variabel bernama filtered, lalu mencetaknya.

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

Ketika Anda menampilkan hasil filter sebagai Sequence, variabel filtered tidak akan menyimpan daftar baru—variabel tersebut akan menyimpan Sequence elemen daftar dan pengetahuan filter yang akan diterapkan untuk elemen tersebut. Setiap kali Anda mengakses elemen Sequence, filter diterapkan, dan hasilnya ditampilkan untuk Anda.

3. Menerapkan evaluasi urutan dengan mengonversinya menjadi List dengan toList(). Cetak hasilnya.

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

4. Jalankan program Anda dan amati output-nya.

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

Untuk memvisualisasikan apa yang terjadi dengan Sequence dan evaluasi lambat, gunakan fungsi map(). Fungsi map() melakukan transformasi sederhana pada setiap elemen dalam urutan.

5. Dengan daftar decorations yang sama seperti di atas, lakukan transformasi dengan map() yang tidak melakukan apa pun, dan cukup menampilkan elemen yang diteruskan. Tambahkan println() untuk menunjukkan setiap kali elemen diakses, dan tetapkan urutan ke variabel bernama lazyMap.

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

6. Cetak lazyMap, cetak elemen pertama lazyMap menggunakan first(), dan cetak lazyMap yang dikonversi menjadi List.

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

7. Jalankan program Anda, dan amati outputnya. Mencetak lazyMap hanya mencetak referensi ke Sequence—println() dalam tidak dipanggil. Mencetak elemen pertama hanya mengakses elemen pertama. Mengonversi Sequence menjadi List akan mengakses semua elemen.

⇒ 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]

8. Buat Sequence baru menggunakan filter asli sebelum menerapkan map. Cetak hasil tersebut.

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

9. Jalankan program Anda dan amati output tambahan. Seperti halnya mendapatkan elemen pertama, println() dalam hanya dipanggil untuk elemen yang diakses.

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

Dalam tugas ini, Anda akan mendapatkan pengantar tentang lambda dan fungsi tingkat tinggi di Kotlin.

Lambda

Selain fungsi yang dinamai secara tradisional, Kotlin mendukung lambda. Lambda adalah ekspresi yang membuat fungsi. Namun, bukannya mendeklarasikan fungsi yang dinamai, Anda akan mendeklarasikan fungsi yang tidak memiliki nama. Ekspresi lambda sekarang dapat diteruskan sebagai data, ini adalah bagian yang bermanfaat. Dalam bahasa lain, lambda disebut fungsi anonim, literal fungsi, atau nama yang serupa.

Fungsi urutan yang lebih tinggi

Anda dapat membuat fungsi urutan yang lebih tinggi dengan meneruskan lambda ke fungsi lain. Pada tugas sebelumnya, Anda telah membuat fungsi tingkat tinggi yang disebut filter. Anda meneruskan ekspresi lambda berikut ke filter sebagai kondisi yang akan diperiksa:
{it[0] == 'p'}

Demikian pula, map adalah fungsi tingkat tinggi, dan lambda yang Anda teruskan ke fungsi tersebut adalah transformasi yang akan diterapkan.

Langkah 1: Pelajari lambda

1. Seperti fungsi yang dinamai, lambda dapat memiliki parameter. Untuk lambda, parameter (dan jenisnya, jika perlu) terletak di sebelah kiri dari fungsi yang disebut dengan panah fungsi ->. Kode untuk mengeksekusi berada di sebelah kanan panah fungsi. Setelah lambda ditetapkan untuk sebuah variabel, Anda dapat memanggilnya sama seperti fungsi.
   
   Dengan menggunakan REPL (Tools > Kotlin > Kotlin REPL), coba kode ini:

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

⇒ 10

Dalam contoh ini, lambda menggunakan Int bernama dirty, dan menampilkan dirty / 2. (Karena penyaringan menghilangkan kotoran.)

2. Sintaksis Kotlin untuk jenis fungsi sangat berhubungan dengan sintaksis untuk lambda-nya. Gunakan sintaksis ini untuk mendeklarasikan variabel yang memiliki fungsi dengan jelas:

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

Inilah fungsi kode tersebut:

• Buat variabel bernama waterFilter.
• waterFilter dapat berupa fungsi apa pun yang mengambil Int dan menampilkan Int.
• Menetapkan lambda ke waterFilter.
• Lambda menampilkan nilai argumen dirty yang dibagi 2.

Perhatikan bahwa Anda tidak perlu menentukan lagi jenis argumen lambda tersebut. Jenis yang dihitung berdasarkan inferensi jenis.

Langkah 2: Buat fungsi urutan yang lebih tinggi

Sejauh ini, contoh lambda sebagian besar terlihat seperti fungsi. Kelebihan utama lambda adalah menggunakannya untuk membuat fungsi urutan yang lebih tinggi, dengan argumen untuk satu fungsi merupakan fungsi lainnya.

1. Tulis fungsi tingkat tinggi. Berikut contoh dasarnya, fungsi yang mengambil dua argumen. Argumen pertama adalah bilangan bulat. Argumen kedua adalah fungsi yang menggunakan bilangan bulat dan menampilkan bilangan bulat. Cobalah di REPL.

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

Isi kode memanggil fungsi yang diteruskan sebagai argumen kedua, dan meneruskan argumen pertama ke fungsi tersebut.

2. Untuk memanggil fungsi ini, teruskan bilangan bulat dan fungsi.

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

⇒ 15

Fungsi yang Anda teruskan tidak harus berupa lambda; fungsi tersebut dapat berupa fungsi bernama biasa. Untuk menentukan argumen sebagai fungsi reguler, gunakan operator ::. Dengan cara ini, Kotlin mengetahui bahwa Anda meneruskan referensi fungsi sebagai argumen, bukan mencoba memanggil fungsi.

3. Coba teruskan fungsi bernama reguler ke updateDirty().

fun increaseDirty( start: Int ) = start + 1

println(updateDirty(15, ::increaseDirty))

⇒ 16

Catatan: Kotlin menganggap parameter apa pun yang mengambil fungsi adalah parameter akhir. Saat bekerja dengan fungsi tingkat tinggi, Kotlin memiliki sintaksis khusus, yang disebut sintaksis panggilan parameter akhir, yang memungkinkan Anda membuat kode yang lebih ringkas. Dalam hal ini, Anda dapat meneruskan lambda untuk parameter fungsi, tetapi Anda tidak perlu meletakkan lambda di dalam tanda kurung.

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

⇒ 42

• Untuk membuat file sumber Kotlin di IntelliJ IDEA, mulailah dengan project Kotlin.
• Untuk mengompilasi dan menjalankan program di IntelliJ IDEA, klik segitiga hijau di samping fungsi main(). Output akan muncul di jendela log di bawah.
• Di IntelliJ IDEA, tentukan argumen command line yang akan diteruskan ke fungsi main() di Run > Edit Configurations.
• Hampir semua hal di Kotlin memiliki nilai. Anda dapat menggunakan fakta ini untuk membuat kode Anda lebih ringkas dengan menggunakan nilai if atau when sebagai ekspresi atau nilai yang ditampilkan.
• Argumen default menghilangkan kebutuhan akan beberapa versi fungsi atau metode. Contoh:
  fun swim(speed: String = "fast") { ... }
• Fungsi rapat, atau fungsi ekspresi tunggal, dapat membuat kode Anda lebih mudah dibaca. Contoh:
  fun isTooHot(temperature: Int) = temperature > 30
• Anda telah mempelajari beberapa dasar-dasar tentang filter, yang menggunakan ekspresi lambda. Contoh:
  val beginsWithP = decorations.filter { it [0] == 'p' }
• Ekspresi lambda adalah ekspresi yang membuat fungsi tanpa nama. Ekspresi lambda ditentukan di antara tanda kurung kurawal {}.
• Dalam fungsi tingkat tinggi, Anda meneruskan fungsi seperti ekspresi lambda ke fungsi lain sebagai data. Contoh:
  dirtyLevel = updateDirty(dirtyLevel) { dirtyLevel -> dirtyLevel + 23}

Ada banyak hal dalam pelajaran ini, terutama jika Anda baru mengenal lambda. Pelajaran berikutnya akan membahas kembali lambda dan fungsi urutan yang lebih tinggi.

Catatan: Anda mungkin telah memperhatikan bahwa di Kotlin, seperti di beberapa bahasa lain, ada lebih dari satu cara yang benar untuk melakukan sesuatu. Membuat kode lebih ringkas terkadang membantu keterbacaan dan bahkan performa, dan terkadang tidak. Saat Anda mempelajari lebih lanjut Kotlin, Anda mungkin menemukan cara yang lebih mudah dan ringkas untuk menyelesaikan sesuatu.

Dokumentasi Kotlin

Jika Anda ingin mendapatkan informasi lebih lanjut tentang topik apa pun dalam kursus ini, atau jika Anda mengalami masalah, https://kotlinlang.org adalah titik awal terbaik Anda.

• Konvensi coding Kotlin
• Idiom Kotlin

• Template string
• Ekspresi when
• Fungsi ekspresi tunggal
• Fungsi tingkat tinggi dan lambda
• Filter
• Urutan
• Sintaksis panggilan parameter akhir

Tutorial Kotlin

Situs https://try.kotlinlang.org menyertakan tutorial lengkap yang disebut Kotlin Koans, interpreter berbasis web, dan serangkaian lengkap dokumentasi referensi dengan contoh.

Kursus Udacity

Untuk melihat kursus Udacity tentang topik ini, lihat Kotlin Bootcamp for Programmers.

IntelliJ IDEA

Dokumentasi untuk IntelliJ IDEA dapat ditemukan di situs JetBrains.

Bagian ini mencantumkan kemungkinan tugas pekerjaan rumah untuk siswa yang mengerjakan codelab ini sebagai bagian dari kursus yang dipimpin oleh instruktur. Instruktur menentukan hal berikut:

• Memberikan pekerjaan rumah jika diperlukan.
• Memberi tahu siswa cara mengirimkan tugas pekerjaan rumah.
• Memberi nilai tugas pekerjaan rumah.

Instruktur bisa menggunakan saran ini sesuai kebutuhan, dan bebas menugaskan pekerjaan rumah lain yang dirasa cocok.

Jika Anda menyelesaikan codelab ini sendiri, gunakan tugas pekerjaan rumah ini untuk menguji pengetahuan Anda.

Jawab pertanyaan-pertanyaan berikut

Pertanyaan 1

Fungsi contains(element: String) menampilkan true jika string element ada dalam string yang dipanggil. Apa output dari kode berikut?

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]

Pertanyaan 2

Dalam definisi fungsi berikut, parameter mana yang wajib diisi?
fun shouldChangeWater (day: String, temperature: Int = 22, dirty: Int = 20, numDecorations: Int = 0): Boolean {...}

▢ numDecorations

▢ dirty

▢ day

▢ temperature

Pertanyaan 3

Anda dapat meneruskan fungsi bernama biasa (bukan hasil pemanggilannya) ke fungsi lain. Bagaimana cara meneruskan increaseDirty( start: Int ) = start + 1 ke updateDirty(dirty: Int, operation: (Int) -> Int)?

▢ updateDirty(15, &increaseDirty())

▢ updateDirty(15, increaseDirty())

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

▢ updateDirty(15, ::increaseDirty)

Lanjutkan ke pelajaran berikutnya: 4. Class dan objek

Untuk ringkasan kursus, termasuk link ke codelab lainnya, lihat "Kotlin Bootcamp for Programmers: Welcome to the course".