ชิ้นส่วนโค้ดเบ็ดเตล็ด

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

ใช้

บทนำ ฟังก์ชัน Kotlin`apply`, 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`คือวิธีที่สง่างามในการดำเนินการกับวัตถุเพื่อให้ได้ผลลัพธ์ที่ต่อเนื่อง โดยที่ยังคงรักษาความถูกต้องสมบูรณ์ของวัตถุดั้งเดิมไว้

บทความที่เกี่ยวข้อง