Kamp Pelatihan Kotlin untuk Programer 3: Fungsi

Codelab ini adalah bagian dari kursus Bootcamp Kotlin untuk Programer. Anda akan mendapatkan manfaat maksimal dari kursus ini jika Anda mengerjakan 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 aplikasi sampel tunggal, pelajaran dalam kursus ini didesain untuk membangun pengetahuan Anda, tetapi bersifat semi-mandiri, sehingga Anda dapat membaca cepat bagian yang sudah Anda pahami. Untuk menyatukannya, banyak contoh menggunakan tema akuarium. Dan jika Anda ingin melihat cerita lengkap akuarium, lihat kursus Udacity Kotlin Bootcamp for Programmers.

Yang harus sudah Anda ketahui

• Dasar-dasar bahasa pemrograman modern, berorientasi objek, dan diketik secara statis
• Cara memprogram dengan class, metode, dan penanganan pengecualian setidaknya dalam satu bahasa
• Cara bekerja dengan 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 Kotlin lebih lanjut.

Yang akan Anda pelajari

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

Yang akan Anda lakukan

• Bekerja dengan REPL untuk mencoba beberapa kode.
• Bekerja sama dengan IntelliJ IDEA untuk menciptakan 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 dalam REPL di codelab sebelumnya:

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

printHello()

⇒ Hello World

Anda menentukan fungsi menggunakan kata kunci fun, diikuti dengan nama fungsi. Seperti bahasa pemrograman lainnya, tanda kurung () digunakan untuk 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 pada Hello Kotlin. (Anda seharusnya sudah memiliki project Hello Kotlin dari codelab sebelumnya.)
3. Pilih New > Kotlin File / Class.
4. Simpan Kind sebagai File, dan beri nama file Hello.
5. Klik OK.

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

Langkah 2: Tambahkan kode dan jalankan program

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() Anda 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 tersebut dan menjalankannya. Hasilnya akan muncul di panel log di bagian bawah, seperti yang ditunjukkan di bawah ini.

Pemrogram Java: Jika Anda menggunakan versi IntelliJ IDEA yang diinstal sebelumnya, bukan menginstal salinan baru, pada saat 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 project SDK 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 Argumen program.
3. Klik OK.

Langkah 4: Ubah kode untuk menggunakan template string

Template string menyisipkan variabel atau ekspresi ke dalam string, dan $ menentukan bahwa bagian string 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 menyertakan argumen yang Anda tentukan.

⇒ Hello, Kotlin!

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

Beberapa bahasa lainnya memiliki pernyataan, yang merupakan baris kode yang tidak memiliki nilai. Di Kotlin, hampir semuanya 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 kode tersebut. (println() tidak menampilkan nilai, sehingga menampilkan 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, lalu inisialisasikan ke 10.
4. Deklarasikan val lain yang disebut isHot, dan tetapkan nilai pengembalian pernyataan if/else ke isHot, seperti yang ditunjukkan dalam kode berikut. Karena ini adalah 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 "semuanya memiliki nilai." Tidak ada nilai yang logis untuk for loop atau while loop, sehingga tidak memiliki nilai. Jika Anda mencoba menetapkan nilai loop ke sesuatu, compiler akan menampilkan error.

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

Langkah 1: Buat beberapa fungsi

Pada langkah ini, Anda mengumpulkan beberapa hal yang telah dipelajari dan membuat fungsi dengan jenis yang berbeda. Anda dapat mengganti konten Hello.kt dengan kode baru ini.

1. Tulis fungsi bernama feedTheFish() yang memanggil randomDay() untuk mendapatkan hari acak dalam seminggu. Gunakan template string untuk mencetak food yang akan dimakan ikan pada hari itu. Untuk saat ini, ikan tersebut makan 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() menggunakan batas bilangan bulat, yang membatasi angka dari Random() hingga 0 hingga 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 dalam 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: Gunakan ekspresi when

Memperluas fungsi ini lebih lanjut, 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. Kode ini juga memastikan kode Anda mencakup semua cabang jika Anda memeriksa enum.

1. Di Hello.kt, tambahkan fungsi bernama fishFood() yang mengambil hari sebagai String dan menampilkan makanan ikan untuk hari sebagai String. Gunakan when(), agar setiap hari ikan mendapatkan makanan yang spesifik. 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.
   
   Memiliki cabang default memastikan bahwa food mendapatkan nilai sebelum ditampilkan, sehingga tidak perlu diinisialisasi lagi. Karena sekarang kode menetapkan string ke food hanya sekali, 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 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 ini.

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 mempelajari fungsi rapat, yang dapat membuat kode Anda lebih ringkas dan lebih mudah dibaca, serta dapat mengurangi jumlah jalur kode untuk pengujian. Fungsi rapat 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 disediakan oleh pemanggil, nilai default akan digunakan. Kemudian, saat Anda menulis metode (fungsi anggota), ini berarti Anda dapat menghindari banyak penulisan versi muatan 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() dengan tiga cara. Pertama-tama, panggil fungsi menggunakan default. Kemudian, panggil fungsi dan teruskan parameter speed tanpa nama, lalu panggil fungsi dengan memberi nama 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 perlu menggunakan nama parameter; Anda cukup meneruskan argumen dalam urutan yang telah ditentukan. Namun, dengan nilai default, ini dapat sedikit membingungkan. Jadi, sebaiknya setel parameter tanpa default terlebih dahulu, dan setelah dengan default.

Langkah 2: Tambahkan parameter yang diperlukan

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 dirty. Fungsi ini menampilkan true jika air harus diganti, yang terjadi jika hari Minggu, jika suhu terlalu tinggi, atau jika air terlalu kotor. Hari diperlukan, tetapi suhu default-nya adalah 22, dan tingkat kotor default-nya 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 masukkan tanggal. Parameter day tidak memiliki default, jadi Anda harus menentukan argumen. Dua parameter shouldChangeWater() yang lain memiliki nilai default, sehingga Anda tidak perlu meneruskan argumen untuk keduanya.
   

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 yang ringkas

Ekspresi when yang Anda tulis di langkah sebelumnya mengemas banyak logika ke dalam sejumlah kecil kode. Jika Anda ingin mengekstraknya sedikit, atau jika kondisi yang akan diperiksa lebih rumit, Anda dapat menggunakan beberapa variabel lokal yang dinamai dengan baik. Namun, cara Kotlin untuk melakukannya adalah dengan fungsi yang ringkas.

Fungsi rapat, atau fungsi ekspresi tunggal, adalah pola umum di Kotlin. Saat 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 rapat 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 untuk menggunakan fungsi rapat.

Nilai default

Nilai default untuk parameter tidak harus berupa nilai. Fungsi tersebut dapat berupa fungsi lain, seperti yang ditunjukkan dalam contoh parsial berikut:

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

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

Dalam tugas ini, Anda mempelajari sedikit tentang filter di Kotlin. Filter merupakan cara yang praktis untuk mendapatkan bagian dari daftar berdasarkan sejumlah kondisi.

Langkah 1: Buat filter

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

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

2. Buat fungsi main() baru dengan garis untuk mencetak hanya dekorasi yang dimulai dengan huruf 'p'. Kode untuk kondisi filter berada dalam tanda kurung kurawal {}, dan it merujuk pada setiap item saat filter diulang. Jika ekspresi menampilkan true, item akan 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 cepat atau lambat. Apakah daftar hasil segera dibuat, atau kapan daftar diakses? Di Kotlin, hal ini terjadi dengan cara apa pun yang Anda perlukan. Secara default, filter bersifat cepat, dan setiap kali Anda menggunakan filter, sebuah daftar akan 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 yang disebut eager, lalu cetak kode tersebut.

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(). Menentukan urutan untuk variabel yang disebut filtered, lalu mencetaknya.

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

Saat Anda menampilkan hasil filter sebagai Sequence, variabel filtered tidak akan memiliki daftar baru—variabel ini akan menyimpan Sequence elemen daftar dan pengetahuan filter yang akan diterapkan untuk elemen tersebut. Kapan pun Anda mengakses elemen Sequence, filter diterapkan dan hasilnya ditampilkan untuk Anda.

3. Paksa 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 outputnya.

⇒ 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, buat transformasi dengan map() yang tidak melakukan apa pun, dan cukup tampilkan elemen yang diteruskan. Tambahkan println() untuk ditampilkan setiap kali elemen diakses, dan tetapkan urutan ke variabel yang disebut 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 akan mencetak referensi ke Sequence—println() bagian 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() bagian dalam hanya dipanggil untuk elemen yang diakses.

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

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

Lambda

Selain fungsi yang dinamai secara tradisional, Kotlin mendukung lambda. lambda adalah ekspresi yang menghasilkan 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 serupa.

Fungsi tingkat tinggi

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

Demikian pula, map adalah fungsi urutan yang lebih tinggi, dan lambda yang Anda teruskan ke sana adalah transformasi yang akan diterapkan.

Langkah 1: Pelajari lambda

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

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

⇒ 10

Dalam contoh ini, lambda mengambil Int yang bernama dirty, dan menampilkan dirty / 2. (Karena pemfilteran menghilangkan kotoran.)

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

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

Inilah fungsi kode tersebut:

• Buat variabel bernama waterFilter.
• waterFilter dapat berupa fungsi apa pun yang menggunakan Int dan menampilkan Int.
• Menetapkan lambda ke waterFilter.
• Lambda menampilkan nilai argumen dirty 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 untuk 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 yang lebih tinggi. Berikut adalah contoh dasar, yaitu fungsi yang menggunakan dua argumen. Argumen pertama adalah bilangan bulat. Argumen kedua adalah fungsi yang mengambil 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 reguler. Untuk menentukan argumen sebagai fungsi biasa, gunakan operator ::. Dengan cara ini, Kotlin tahu 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. Ketika bekerja dengan fungsi urutan yang lebih tinggi, Kotlin memiliki sintaksis khusus, yang disebut sintaksis panggilan parameter terakhir, yang memungkinkan Anda membuat kode lebih ringkas. Dalam hal ini, Anda dapat meneruskan lambda untuk parameter fungsi, namun 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 InteliJ IDEA, klik segitiga hijau di samping fungsi main(). Output akan muncul di jendela log di bawah.
• Di InteliJ IDEA, tentukan argumen command line untuk diteruskan ke fungsi main() di Menjalankan > Edit Konfigurasi.
• Hampir semua hal di Kotlin memiliki nilai. Anda dapat menggunakan fakta ini untuk membuat kode lebih ringkas dengan menggunakan nilai if atau when sebagai ekspresi atau nilai kembalian.
• 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 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 yang lebih 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 selanjutnya membahas kembali lambda dan fungsi urutan yang lebih tinggi.

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

Dokumentasi Kotlin

Jika Anda menginginkan informasi lebih lanjut tentang setiap topik dalam kursus ini, atau jika mengalami kesulitan, https://kotlinlang.org adalah langkah awal yang terbaik.

• Konvensi coding Kotlin
• Idiom Kotlin

• Template string
• Ekspresi when
• Fungsi ekspresi tunggal
• Fungsi dan lambda dengan urutan yang lebih tinggi
• Filter
• Urutan
• Sintaksis panggilan parameter akhir

Tutorial Kotlin

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

Kursus Udacity

Untuk melihat kursus Udacity tentang topik ini, lihat Bootcamp Kotlin untuk Pemrogram

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. Terserah instruktur untuk melakukan hal berikut:

• Tugaskan pekerjaan rumah jika diperlukan.
• Berkomunikasi dengan siswa cara mengirimkan tugas pekerjaan rumah.
• Beri nilai tugas pekerjaan rumah.

Instruktur dapat menggunakan saran ini sesedikit atau sebanyak yang mereka inginkan, dan harus bebas memberikan pekerjaan rumah lain yang dirasa sesuai.

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

Jawab pertanyaan berikut

Pertanyaan 1

Fungsi contains(element: String) menampilkan true jika string element terdapat dalam string yang dipanggil. Apa yang akan menjadi 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, manakah dari parameter yang diperlukan?
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 reguler (bukan hasil dari memanggilnya) ke fungsi lain. Bagaimana Anda 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: Selamat datang di kursus."