0Pricing
Kotlin Academy · บทเรียน

also: ผลข้างเคียงโดยไม่เปลี่ยนตัวรับ

ใช้ also สำหรับการบันทึก การดีบัก และการดำเนินการที่มีเพียงผลข้างเคียง

also: ผลข้างเคียงโดยไม่เปลี่ยนตัวรับ เป็นบทเรียน Kotlin Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Kotlin Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Kotlin Academy มีบทเรียนทั้งหมด 4 บทเรียน

ทำความรู้จัก also อย่างรวดเร็ว

also จะเรียกใช้บล็อกโดยให้ตัวรับเป็น it และส่งคืนตัวรับเดิมโดยไม่เปลี่ยนแปลง เหมาะอย่างยิ่งสำหรับผลข้างเคียง เช่น การบันทึกข้อมูล การแก้ไขข้อบกพร่อง และการตรวจสอบ โดยไม่รบกวนเชน

พื้นฐานของ also

also { ... } จะดำเนินการผลข้างเคียงและส่งค่าดั้งเดิมกลับมา จึงทำให้การเรียกใช้ดำเนินต่อไปได้อย่างเป็นธรรมชาติ

fun main() {
    val nums = listOf(1, 2, 3, 4)
        .also { println("input: $it") }
        .filter { it % 2 == 0 }
        .also { println("filtered: $it") }
    println(nums)
}

ใช้ also สำหรับการบันทึกข้อมูล

เพิ่มคำสั่งบันทึกข้อมูลระหว่างสายการประมวลผลได้โดยไม่ทำให้การทำงานต่อเนื่องหยุดชะงัก

fun main() {
    val processed = "  Hello, Kotlin!  "
        .also { println("raw: '$it'") }
        .trim()
        .also { println("trimmed: '$it'") }
        .uppercase()
    println(processed)
}

ใช้ also สำหรับการแก้ไขข้อบกพร่อง

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

fun main() {
    val sum = (1..5).toList()
        .also { println("list: $it") }
        .sum()
        .also { println("sum: $it") }
    println("final: $sum")
}

เปรียบเทียบ also กับ apply

apply ใช้ this (เหมาะกับการกำหนดค่า) ส่วน also ใช้ it (เหมาะกับการอ้างอิงอย่างชัดเจนและผลข้างเคียง)

class Counter {
    var value: Int = 0
}
fun main() {
    val c = Counter().apply { value = 10 } // uses this implicitly
    val d = Counter().also { it.value = 10 } // uses it explicitly
    println("${c.value} / ${d.value}")
}

ใช้ also สำหรับผลข้างเคียงระหว่างการเริ่มต้น

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

class Repository {
    val cache = mutableMapOf<String, String>()
    fun init() = println("Repository initialized")
}
fun main() {
    val r = Repository().also { it.init() }
    r.cache["key"] = "value"
    println(r.cache)
}

also ส่งคืนค่าเดิม

ตัวรับจะถูกส่งต่อโดยไม่เปลี่ยนแปลง ทำให้ต่อเชนได้ง่าย

fun main() {
    val len = "Hello".also { println("got: $it") }.length
    println(len) // 5
}

ใช้ also สำหรับการตรวจสอบความถูกต้อง

เรียกใช้การตรวจสอบยืนยันระหว่างเชน

fun main() {
    val n = listOf(1, 2, 3, 4)
        .filter { it > 0 }
        .also { require(it.isNotEmpty()) { "must have positives" } }
        .sum()
    println(n)
}

การใช้ also และ let ร่วมกัน

ใช้ also สำหรับผลข้างเคียง และใช้ let สำหรับการแปลงค่าในสายการประมวลผลเดียวกัน

fun main() {
    val raw: String? = "  42  "
    val n = raw
        ?.also { println("raw: '$it'") }
        ?.let { it.trim().toIntOrNull() }
        ?.also { println("parsed: $it") }
    println(n)
}

ใช้ also เพื่อเพิ่มลงในคอลเลกชัน

เพิ่มออบเจ็กต์ที่สร้างขึ้นลงในรายการแบบแทรกอยู่ในนิพจน์ได้

class User(val name: String)
fun main() {
    val users = mutableListOf<User>()
    val ada = User("Ada").also { users.add(it) }
    val ben = User("Ben").also { users.add(it) }
    println(users.map { it.name })
}

ควรใช้ also เมื่อใด

เลือกใช้ also เมื่อคุณต้องการผลข้างเคียง เช่น บันทึกข้อมูล ตรวจสอบ หรือลงทะเบียน แต่ต้องการให้ค่าดั้งเดิมไหลต่อไป

fun main() {
    val total = listOf(10, 20, 30, 40, 50)
        .also { println("count: ${it.size}") }
        .filter { it >= 30 }
        .also { println("kept: $it") }
        .sum()
    println("total: $total")
}

รูปแบบที่ควรหลีกเลี่ยง: ใช้ also เพื่อกำหนดค่าใหม่

อย่าใช้ also เมื่อคุณต้องการแปลงค่าจริง ๆ เพราะนั่นเป็นหน้าที่ของ let/run

fun main() {
    val name = "ada"
    // BAD: also returns receiver, so upper is wrong
    // val upper = name.also { it.uppercase() } // upper == "ada"
    val upper = name.let { it.uppercase() }
    println(upper) // ADA
}

ตรวจสอบอย่างรวดเร็ว

หลังจากเรียกใช้บล็อกแล้ว also ส่งคืนค่าใด

ทบทวน

also จะเรียกใช้บล็อกผลข้างเคียงโดยใช้ it และส่งคืนตัวรับ ใช้สำหรับการบันทึกข้อมูล การแก้ไขข้อบกพร่อง การตรวจสอบ และการลงทะเบียน หรือทุกกรณีที่คุณต้องการตรวจดูค่าโดยไม่เปลี่ยนแปลง สำหรับการแปลงค่า ให้ใช้ let หรือ run แทน

คำถามที่พบบ่อย

บทเรียน “also: ผลข้างเคียงโดยไม่เปลี่ยนตัวรับ” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “also: ผลข้างเคียงโดยไม่เปลี่ยนตัวรับ” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Kotlin Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Kotlin Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “also: ผลข้างเคียงโดยไม่เปลี่ยนตัวรับ”

ใช้ also สำหรับการบันทึก การดีบัก และการดำเนินการที่มีเพียงผลข้างเคียง คุณปฏิบัติ Kotlin Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Kotlin Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Kotlin Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน

บทเรียน “also: ผลข้างเคียงโดยไม่เปลี่ยนตัวรับ” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Kotlin Academy นี้ได้ไหม

ได้ บทเรียน Kotlin Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. apply และ with: ตั้งค่าและส่งคืนค่า
  2. let และ run: แปลงค่าและกำหนดขอบเขต
  3. also: ผลข้างเคียงโดยไม่เปลี่ยนตัวรับ
  4. เลือกฟังก์ชันขอบเขตให้เหมาะสม: คู่มือการตัดสินใจ
← กลับไปที่ Kotlin Academy