บันทึกช่วยจำ Kotlin
เผยแพร่เมื่อ 29 May 2022
ลิงก์ที่ดี
ชิ้นส่วนโค้ดเบ็ดเตล็ด
map reduce
แปลงลิสต์ของ bite ให้เป็นลิสต์ของ string และสรุปลิสต์ของ string นั้น
ใน string ที่มีการต่อกัน (concatenation) วิธีการล็อก request ที่ส่งออกไป (requestBodyContent:byte[])
log.info(
requestBodyContent!!.map { it.toInt().toChar().toString() }
.reduce { request: String, s: String -> request + s }
)
enum และ sealed classes
functional interface และ method reference
เราสามารถแปลงเอนทิตีให้เป็นโดเมนโมเดลของ dto ได้ด้วย method reference (สไตล์ functional - java 8)
fun findAllByLoginNot(
pageable:Pageable,
login:String)
:Page<UserDto> {
return userDao.findAllByLoginNot(
pageable,
login).map(::fromEntity)
}
หนึ่งhttps://stackoverflow.com/a/22245383/837404[คำอธิบายที่ดี]
ดักจับเอาต์พุตมาตรฐาน
package functional
import java.io.ByteArrayOutputStream
import java.io.PrintStream
import java.lang.System.out
import java.lang.System.setOut
import kotlin.test.AfterTest
import kotlin.test.BeforeTest
import kotlin.test.Test
import kotlin.test.assertEquals
class BasicsHOF {
private val standardOut: PrintStream? = out
private val outputStreamCaptor = ByteArrayOutputStream()
@BeforeTest
fun setUp() = setOut(PrintStream(outputStreamCaptor))
@AfterTest
fun tearDown() = setOut(standardOut)
@Test
fun `three times dope`() {
3.times { println("Hello") }
assertEquals(
buildString {
repeat(3) { append("Hello\n") }
deleteAt(length - 1)
}, outputStreamCaptor
.toString()
.trim()
)
}
fun Int.times(fn: () -> Unit) = (1..this).forEach { _ -> fn() }
}
ความแตกต่างระหว่าง apply, run, let, also, use และ with ใน kotlin คืออะไร?
การเปรียบเทียบฟังก์ชัน Kotlin และการใช้งานรูปแบบ Lambda Reference
ใช้
run, let, also, use, et `with`นำเสนอวิธีการที่แตกต่างกันในการจัดการกับวัตถุ ซึ่งแต่ละวิธีมีกรณีการใช้งานและพฤติกรรมเป็นของตัวเอง นอกจากนี้ lambda reference forms ยังช่วยให้โค้ดอ่านง่ายขึ้นและนำกลับมาใช้ใหม่ได้โดยการอ้างอิงถึงฟังก์ชันแลมบ์ดาที่มีอยู่แล้วฟังก์ชัน`apply`ใช้สำหรับกำหนดค่าอ็อบเจกต์ในระหว่างการสร้าง โดยจะคืนค่าอ็อบเจกต์ที่ถูกเรียกใช้งานนั้นๆ
ตัวอย่างพร้อม lambda reference:
val someObject = SomeClass().apply(::configureObject)
ตัวอย่างด้วย lambda:
val someObject = SomeClass().apply {
// configuration des propriétés de someObject
}
รัน
ฟังก์ชัน`run`ถูกใช้เพื่อรันบล็อกโค้ดบนออบเจ็กต์และส่งคืนผลลัพธ์ของบล็อกโค้ดนั้น
ตัวอย่างพร้อม lambda reference:
val result = someObject.run(::someFunction)
ตัวอย่างด้วย lambda:
val result = someObject.run {
// bloc de code à exécuter sur someObject
// la dernière expression est renvoyée
}
ให้
ฟังก์ชัน`let`ถูกใช้เพื่อรันบล็อกของโค้ดบนออบเจกต์และส่งคืนผลลัพธ์ของบล็อกโค้ดนั้น
ตัวอย่างพร้อม lambda reference:
val result = someObject.let(::processObject)
ตัวอย่างด้วย lambda:
val result = someObject.let {
// bloc de code à exécuter sur someObject
// la dernière expression est renvoyée
}
นอกจากนี้
ฟังก์ชัน`also`ถูกใช้เพื่อดำเนินการเพิ่มเติมกับอ็อบเจกต์ และส่งคืนอ็อบเจกต์ที่ถูกเรียกใช้งานนั้น
ตัวอย่างพร้อม lambda reference:
someObject.also(::performAdditionalAction)
ตัวอย่างด้วย lambda:
someObject.also {
// action additionnelle sur someObject
}
ใช้
ฟังก์ชัน`use`ใช้สำหรับทำงานกับทรัพยากรที่ต้องปิดหลังจากใช้งาน โดยจะเรียกฟังก์ชัน`close`ที่ตอนท้ายของบล็อก
ตัวอย่างพร้อม lambda reference:
someResource.use(::useResource)
ตัวอย่างด้วย lambda:
someResource.use {
// travailler avec la ressource
}
ด้วย
ฟังก์ชัน`with`ใช้สำหรับเรียกใช้หลายเมธอดบนออบเจ็กต์โดยไม่ต้องพิมพ์ชื่อซ้ำ และจะคืนค่าผลลัพธ์ของนิพจน์สุดท้าย
ตัวอย่างพร้อม lambda reference:
val result = with(someObject, ::processWithObject)
ตัวอย่างด้วย lambda:
val result = with(someObject) {
// appeler des méthodes sur someObject
// la dernière expression est renvoyée
}
โดยใช้รูปแบบ lambda reference หรือบล็อก`{}`คุณสามารถห่อหุ้มลอจิกไว้ในฟังก์ชันที่แยกจากกัน ซึ่งจะช่วยเพิ่มความอ่านง่ายและการนำโค้ดกลับมาใช้ซ้ำได้
let` ส่งคืนอ็อบเจกต์พร้อมกับผลข้างเคียง (side effects) ที่เกิดขึ้น หรือส่งคืนในสถานะเริ่มต้นขณะที่เข้าสู่ฟังก์ชัน (let)?
ให้ Function ใน Kotlin
ฟังก์ชัน`let`ใน Kotlin ถูกใช้เพื่อดำเนินการกับออบเจกต์และส่งคืนผลลัพธ์ที่แตกต่างออกไป อย่างไรก็ตาม สิ่งสำคัญที่ต้องสังเกตคือฟังก์ชัน`let`ไม่แก้ไขสถานะเริ่มต้นของอ็อบเจกต์ที่ถูกเรียกใช้
| ลายเซ็น | inline fun <T, R> T.let(block: (T) → R): R |
|---|
| การใช้งาน | ฟังก์ชัน`let`มักใช้เพื่อนำการแปลง (transformations) มาใช้กับวัตถุและรับผลลัพธ์ตามการแปลงเหล่านั้น |
|---|
| ผลลัพธ์ | ค่าที่ส่งคืนโดยฟังก์ชัน`let`คือผลลัพธ์ของ lambda expression ที่ส่งมาเป็นอาร์กิวเมนต์ ซึ่งโดยทั่วไปจะเป็นผลลัพธ์ของการดำเนินการต่างๆ ที่ทำกับวัตถุนั้น |
|---|
| ผลข้างเคียง (Side Effects) | แม้ว่าฟังก์ชัน`let`อาจมีผลข้างเคียง (side effects) ต่อออบเจกต์เมื่อถูกนำมาใช้ใน lambda expression แต่จะไม่เปลี่ยนแปลงสถานะเริ่มต้นของตัวออบเจกต์เอง |
|---|
ดังนั้น ฟังก์ชัน`let`คือวิธีที่สง่างามในการดำเนินการกับวัตถุเพื่อให้ได้ผลลัพธ์ที่ต่อเนื่อง โดยที่ยังคงรักษาความถูกต้องสมบูรณ์ของวัตถุดั้งเดิมไว้