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

let, also และ run กับตัวรับ Nullable

ใช้ฟังก์ชันขอบเขตเพื่อประมวลผลโค้ดเฉพาะเมื่อค่าไม่ใช่ null

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

ฟังก์ชันขอบเขตกับค่าที่อาจเป็นค่าว่าง

ฟังก์ชันขอบเขตอย่าง let also และ run ทำงานร่วมกับการเรียกแบบปลอดภัย ?. ได้เป็นอย่างดี เพื่อให้บล็อกทำงานเฉพาะเมื่อตัวรับไม่เป็นค่าว่าง

let กับการเรียกแบบปลอดภัย

obj?.let { ... } จะเรียกใช้บล็อกก็ต่อเมื่อ obj ไม่เป็นค่าว่าง ภายในบล็อก it จะอ้างอิงค่าที่ไม่เป็นค่าว่าง

fun main() {
    val name: String? = "Kotlin"
    name?.let {
        println("Length: ${it.length}")
        println("Upper: ${it.uppercase()}")
    }
}

let จะข้ามบล็อกเมื่อเป็นค่าว่าง

หากตัวรับเป็นค่าว่าง บล็อก let ทั้งหมดจะถูกข้าม

fun main() {
    val name: String? = null
    val result = name?.let {
        println("never printed")
        it.length
    }
    println(result) // null
}

let คืนค่า

let จะคืนค่านิพจน์สุดท้ายของบล็อก จึงสามารถเชื่อมต่อกับ Elvis เพื่อกำหนดค่าเริ่มต้นได้

fun main() {
    val raw: String? = "  hello "
    val cleaned = raw?.let { it.trim().uppercase() } ?: "(empty)"
    println(cleaned) // HELLO
}

also สำหรับผลข้างเคียง

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

fun main() {
    val name: String? = "Alice"
    val len = name?.also { println("Processing: $it") }?.length
    println("len = $len")
}

also รักษาค่าเดิม

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

fun main() {
    val items: List<Int>? = listOf(1, 2, 3)
    items?.also { println("Got list of size ${it.size}") }
           ?.forEach { println(it) }
}

run กับการเรียกแบบปลอดภัย

obj?.run { ... } จะเรียกใช้บล็อกโดยผูก this ให้เป็นตัวรับ ใช้เมื่อต้องการเข้าถึงสมาชิกโดยไม่ต้องเติมคำนำหน้า it.

fun main() {
    val name: String? = "Kotlin"
    val info = name?.run {
        "len=$length upper=${uppercase()}"
    }
    println(info)
}

let เทียบกับ run

let ใช้ it เป็นอาร์กิวเมนต์ของแลมบ์ดา ส่วน run ใช้ this เป็นตัวรับ เลือกแบบที่อ่านเข้าใจได้ดีกว่า

class User(val name: String, val age: Int)
fun main() {
    val user: User? = User("Ada", 35)
    user?.let { "${it.name} age ${it.age}" }.also(::println)
    user?.run { "$name age $age" }.also(::println)
}

การเชื่อมขอบเขตหลายรายการ

เชื่อมฟังก์ชันขอบเขตหลายรายการตลอดสายการประมวลผล เพื่อแปลงข้อมูลทีละขั้นและบันทึกข้อมูลระหว่างทาง

fun main() {
    val raw: String? = "  hello  "
    val result = raw
        ?.also { println("raw: '$it'") }
        ?.let { it.trim() }
        ?.also { println("trimmed: '$it'") }
        ?.uppercase()
    println(result) // HELLO
}

let กับ takeIf

รวม takeIf ซึ่งใช้กรองข้อมูลกับ let เพื่อเรียกใช้งานตามเพรดิเคต

fun main() {
    val name: String? = "Kotlin"
    name?.takeIf { it.length > 3 }
        ?.let { println("Long name: $it") }
}

รูปแบบที่ควรหลีกเลี่ยง: if ซ้อนกัน

ก่อนมีฟังก์ชันขอบเขต:

fun main() {
    val name: String? = "Alice"
    // OLD WAY:
    if (name != null) {
        val upper = name.uppercase()
        println(upper)
    }
    // NEW WAY:
    name?.let { println(it.uppercase()) }
}

ตรวจสอบความเข้าใจ

ฟังก์ชันขอบเขตใดคืนค่าตัวรับโดยไม่เปลี่ยนแปลง และใช้เป็นหลักสำหรับผลข้างเคียง

สรุปทบทวน

รวม ?. กับ let ซึ่งบล็อกคืนค่าและใช้ it run ซึ่งบล็อกคืนค่าและใช้ this หรือ also ซึ่งคืนค่าตัวรับและใช้สำหรับผลข้างเคียง ฟังก์ชันทั้งหมดจะข้ามการทำงานหากตัวรับเป็นค่าว่าง

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

บทเรียน “let, also และ run กับตัวรับ Nullable” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “let, also และ run กับตัวรับ Nullable”

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

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

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

บทเรียน “let, also และ run กับตัวรับ Nullable” ใช้เวลานานแค่ไหน

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

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

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

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

  1. ชนิด Nullable และตัวปรับแต่ง ?
  2. Safe Call ?. และ Elvis ?: ในโค้ดจริง
  3. let, also และ run กับตัวรับ Nullable
  4. ตัวดำเนินการ !!: เมื่อใดและเหตุใดควรหลีกเลี่ยง
← กลับไปที่ Kotlin Academy