Mengingat pengumuman Google baru-baru ini tentang dukungan resmi Kotlin untuk pengembangan Android, saya pikir mungkin sudah saatnya untuk memberi polling kepada masyarakat tentang beberapa kiat bermain golf yang luar biasa untuk bahasa JVM yang relatif baru ini.

Kotlin menyertakan kombinasi fitur yang unik di antara saudara-saudara JVM-nya yang membuatnya berpotensi menarik untuk bermain golf:

• operator kelebihan beban
• fungsi ekstensi lokal , infiks , dan statis
• gips cerdas
• Pembangun tipe aman ala groovy
• ketik alias
• rentang
• paket koleksi fungsional yang luas
• dukungan scripting

Jadi, bagaimana saya memeras beberapa byte terakhir dari program Kotlin saya? Tolong, satu tip per jawaban.

Fungsi Ekstensi

Fungsi ekstensi benar-benar dapat membantu mengurangi nama metode bawaan, dan rangkaiannya, contohnya bisa:

fun String.c() = this.split("").groupingBy{it}.eachCount()

tetapi ini hanya membantu jika:

A) Panggilan cukup lama untuk membatalkan definisi

B) Panggilan diulang

Penggunaan lambdas daripada metode

Lambdas dapat kembali tanpa menggunakan kata kunci kembali, menghemat byte

KotlinGolfer

Sebuah proyek yang saya mulai di sini yang mengambil kode Kotlin cantik dan memberikan posting dengan tes dan tautan TIO secara otomatis

Gunakan +sebagai gantitoString

Seperti yang bisa diduga, Stringmembebani +operator untuk penggabungan string, seperti itu.

print("Hel" + "lo")

Namun, memeriksa dokumen memberi tahu kami bahwa ia menerima Any?, bukan hanya String. Sebagaimana dinyatakan:

Mengembalikan string yang diperoleh dengan menggabungkan string ini dengan representasi string dari objek lain yang diberikan.

Dengan kata lain, String + anythingpastikan untuk memanggil .toString()sisi kanan sebelum bergabung. Hal ini memungkinkan kita untuk mempersingkat it.toString()untuk ""+it, besar-besaran 8 tabungan byte terbaik dan 6 byte paling buruk.

Gunakan foldsebagai gantijoinToString

Terkait dengan hal di atas, jika Anda menelepon mapkemudian joinToString, Anda dapat mempersingkatnya dengan menggunakan fold.

list.map{it.repeat(3)}.joinToString("")
list.fold(""){a,v->a+v.repeat(3)}

Mulai dari 1.3 Anda dapat menghilangkan args di main main () sepenuhnya, sehingga mencukur 18 karakter (yaitu, panjang args:Array<String>).

Menentukan Int dalam params

Ini kemungkinan akan memiliki beberapa kasus penggunaan yang cukup spesifik di mana mungkin sepadan, tetapi dalam pertanyaan terakhir saya bermain golf saya menemukan saya bisa menghemat beberapa byte dengan mendefinisikan variabel saya sebagai parameter opsional daripada mendefinisikan mereka dalam fungsi.

Contoh dari jawaban saya untuk pertanyaan ini :

mendefinisikan variabel dalam fungsi:

fun String.j()={var b=count{'-'==it}/2;var a=count{'/'==it};listOf(count{'o'==it}-a,a-b,b)}

mendefinisikan variabel sebagai params:

fun String.j(b:Int=count{'-'==it}/2,a:Int=count{'/'==it})=listOf(count{'o'==it}-a,a-b,b)

karena var a=panjangnya a:Int=sama dengan jumlah byte yang sama untuk mendefinisikannya (ini hanya berlaku untuk Int) namun karena saya sekarang hanya memiliki 1 baris dalam fungsi saya dapat menjatuhkan {}dan saya juga menjatuhkan satu ;(yang lain adalah diganti dengan a ,)

Jadi jika ada fungsi yang memerlukan mendefinisikan Int, dan akan menjadi 1 liner jika Anda tidak mendefinisikan int dalam fungsi - maka melakukannya sebagai parameter akan menghemat beberapa byte

Fungsi toinfiks

Ada fungsi infix standar bernama toyang menciptakan Pairs dari dua nilai. Ini biasanya digunakan dengan mapOf()untuk mendefinisikan Maptetapi berpotensi dapat menjadi jauh lebih pendek daripada Pair()konstruktor.

Pair(foo,bar)   //constructor
foo to bar      //best case 
(foo)to(bar)
((foo)to(bar))  //worst case

Destrukturisasi dalam argumen lambda

Katakanlah Anda ingin menerima Pair<*,*>dalam lambda. Biasanya, menangani ini akan mengganggu. Sebagai contoh, inilah lambda yang mengambil a Pairdan memeriksa apakah kedua nilainya sama:

{it.first==it.second}

Ini bertele-tele dan canggung. Untungnya, Kotlin memungkinkan Anda untuk menghancurkan segala jenis yang dapat dirusak (jenis apa pun yang mengimplementasikan componentN()metode, seperti Pair, Tripledll.) Sebagai argumen untuk sebuah lambda. Jadi, kita dapat menulis ulang ini dengan cara berikut:

{(a,b)->a==b}

Itu terlihat mirip dengan pola yang cocok dengan tuple dalam sesuatu seperti F #, dan dalam banyak kasus. Tetapi berbagai jenis di Kotlin mendukung perusakan ( MatchResultyang bermanfaat.)

Anda dapat mengambil lebih banyak argumen. Katakanlah lambda Anda harus mengambil Pairdan nilai tambah. Anda cukup menulis tanda tangan lambda seperti ini:

(a,b),c->  // pair first
a,(b,c)->  // pair second