จากการประกาศเมื่อเร็ว ๆ นี้ของ Google เกี่ยวกับการสนับสนุนKotlinอย่างเป็นทางการสำหรับการพัฒนา Android ผมคิดว่าอาจถึงเวลาที่จะสำรวจชุมชนสำหรับเคล็ดลับการเล่นกอล์ฟที่ยอดเยี่ยมสำหรับภาษา JVM ที่ค่อนข้างใหม่นี้

Kotlin มีการผสมผสานคุณสมบัติที่ไม่เหมือนใครในหมู่พี่น้อง JVM ซึ่งทำให้น่าสนใจสำหรับการเล่นกอล์ฟ:

• ผู้ประกอบการมากไป
• ฟังก์ชั่นท้องถิ่น , มัดและฟังก์ชั่นส่วนขยายคงที่
• สมาร์ทดุจ
• ผู้สร้างแบบปลอดภัยชนิด Groovy
• พิมพ์นามแฝง
• ช่วง
• แพคเกจคอลเลกชันการทำงานที่กว้างขวาง
• สนับสนุนการเขียนสคริปต์

ดังนั้นฉันจะบีบสองสามไบต์สุดท้ายออกจากโปรแกรม Kotlin ของฉันได้อย่างไร กรุณาหนึ่งเคล็ดลับต่อคำตอบ

ฟังก์ชั่นการขยาย

ฟังก์ชั่นส่วนขยายสามารถช่วยลดชื่อของวิธีการที่มีอยู่ภายในและเชนของพวกเขาได้ตัวอย่างเช่น:

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

แต่สิ่งนี้จะช่วยถ้า:

A) สายยาวพอที่จะยกเลิกคำจำกัดความ

B) การโทรซ้ำแล้วซ้ำอีก

ใช้แลมบ์ดามากกว่าวิธีการ

แลมบ์ดาสามารถกลับมาได้โดยไม่ต้องใช้คีย์เวิร์ด return เพื่อเป็นการประหยัดไบต์

KotlinGolfer

โครงการที่ฉันเริ่มต้นที่นี่ซึ่งใช้รหัส Kotlin ที่สวยและให้โพสต์พร้อมการทดสอบและลิงก์ TIO โดยอัตโนมัติ

ใช้+แทนtoString

อย่างที่ใคร ๆ ก็คาดไม่ถึงStringโอเวอร์โหลด+โอเปอเรเตอร์สำหรับการต่อข้อมูลสตริงเช่นนั้น

print("Hel" + "lo")

อย่างไรก็ตามการตรวจสอบเอกสารบอกเราว่าจะยอมรับไม่เพียงAny? Stringตามที่ระบุไว้:

ส่งคืนสตริงที่ได้รับโดยการเชื่อมสตริงนี้กับการแทนค่าสตริงของวัตถุอื่นที่กำหนด

กล่าวอีกนัยหนึ่งString + anythingให้แน่ใจว่าได้โทร.toString()ทางด้านขวามือก่อนที่จะต่อเข้าด้วยกัน นี้ช่วยให้เราสั้นลงit.toString()ไป""+it, ขนาดใหญ่ 8 เงินฝากออมทรัพย์ไบต์ที่ดีที่สุดและ 6 ไบต์ที่เลวร้ายที่สุด

ใช้foldแทนjoinToString

เกี่ยวข้องกับด้านบนหากคุณโทรmapแล้วjoinToStringคุณสามารถย่อให้สั้นลงได้โดยใช้foldแทน

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

เริ่มต้นจาก 1.3 คุณสามารถละเว้น args in main main () ได้อย่างสมบูรณ์ดังนั้นจึงตัดทิ้ง 18 ตัวอักษร (นั่นคือความยาวของargs:Array<String>)

การนิยาม Int's ใน params

นี่อาจเป็นกรณีการใช้งานที่ค่อนข้างเฉพาะซึ่งอาจคุ้มค่า แต่ในคำถามล่าสุดที่ฉันตีกอล์ฟฉันพบว่าฉันสามารถบันทึกสองสามไบต์โดยการกำหนดตัวแปรของฉันเป็นพารามิเตอร์ทางเลือกแทนที่จะกำหนดไว้ในฟังก์ชัน

ตัวอย่างจากคำตอบของฉันนี้คำถาม:

การกำหนดตัวแปรในฟังก์ชั่น:

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

การกำหนดตัวแปรเป็นพารามิเตอร์:

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

เพราะvar a=มีความยาวเท่าa:Int=กันซึ่งจะเป็นจำนวนไบต์ที่เท่ากันในการกำหนด (ในกรณีนี้เท่านั้นInt) อย่างไรก็ตามเนื่องจากตอนนี้ฉันมีเพียง 1 บรรทัดในฟังก์ชั่นที่ฉันสามารถวาง{}และฉันยังวางหนึ่ง;(อีกอันคือ แทนที่ด้วย a ,)

ดังนั้นหากมีฟังก์ชั่นใด ๆ ที่จำเป็นต้องมีการกำหนดค่า Int และจะเป็น 1 ซับถ้าคุณไม่ได้กำหนดค่า int ในฟังก์ชั่น - จากนั้นการทำเช่นนี้เป็นพารามิเตอร์จะประหยัดสองไบต์

toฟังก์ชั่นมัด

มีฟังก์ชั่น infix มาตรฐานชื่อtoที่สร้างPairs ของสองค่า มันมักใช้กับmapOf()การกำหนดMaps แต่มันอาจจะสั้นกว่าคอนPair()สตรัคเตอร์มาก

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

การทำลายล้างในการโต้แย้งแลมบ์ดา

สมมติว่าคุณต้องการยอมรับPair<*,*>แลมบ์ดา ปกติแล้วการจัดการสิ่งนี้จะน่ารำคาญ ตัวอย่างเช่นนี่คือแลมบ์ดาที่รับ a Pairและตรวจสอบว่าค่าทั้งสองเท่ากันหรือไม่:

{it.first==it.second}

นี่เป็นเวลานานและเงอะงะ โชคดีที่ Kotlin ช่วยให้คุณสามารถ destructure ประเภท destructable ใด ๆ (ประเภทใด ๆ ที่ดำเนินการcomponentN()วิธีการเช่นPair, Tripleฯลฯ ) เป็นข้อโต้แย้งที่จะแลมบ์ดา ดังนั้นเราสามารถเขียนสิ่งนี้ด้วยวิธีต่อไปนี้:

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

มันดูคล้ายกับรูปแบบที่ตรงกับสิ่งอันดับใน F # และในหลาย ๆ กรณี แต่ประเภทต่าง ๆ ใน Kotlin รองรับการทำลายล้าง ( MatchResultเป็นประโยชน์อย่างหนึ่ง)

คุณสามารถโต้แย้งมากกว่านี้ได้ สมมติว่าแลมบ์ดาของคุณต้องใช้Pairและค่าเพิ่มเติม คุณแค่เขียนแลมบ์ดาแบบนี้:

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