Kotlin Academy · บทเรียน

ตัวดำเนินการ !!

บังคับให้ไม่เป็นค่าว่างและความเสี่ยง

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

บังคับให้ไม่เป็นค่าว่าง

บางครั้งคุณแน่ใจว่าค่าที่เป็นค่าว่างได้ไม่ใช่ค่าว่าง แต่คอมไพเลอร์ยังคงแจ้งข้อผิดพลาด

ตัวดำเนินการยืนยันว่าไม่เป็นค่าว่าง !! จะบอกคอมไพเลอร์ให้เชื่อคุณและถือว่าค่านั้นไม่เป็นค่าว่าง

การใช้งานพื้นฐาน

การเพิ่ม !! จะแปลงชนิดที่เป็นค่าว่างได้ให้เป็นชนิดที่สอดคล้องกันซึ่งไม่เป็นค่าว่าง

หากค่านั้นไม่เป็นค่าว่างจริง โค้ดจะทำงานเหมือนการเรียกปกติทุกประการ

fun main() {
    val name: String? = "Kotlin"
    println(name!!.length)
}

อันตราย

หากค่านั้นเป็น null จริง !! จะโยน NullPointerException ณ จุดนั้น

นี่เป็นจุดเดียวที่ Kotlin ยอมให้เกิด NPE และเป็นความรับผิดชอบของคุณโดยสมบูรณ์

fun main() {
    val name: String? = null
    try {
        println(name!!.length)
    } catch (e: NullPointerException) {
        println("Boom: NullPointerException")
    }
}

เหตุผลที่มีตัวดำเนินการนี้

ตัวดำเนินการนี้ตั้งใจออกแบบให้ดูไม่สวยงาม เครื่องหมายอัศเจรีย์สองตัวจะสะดุดตาในการตรวจสอบโค้ด และส่งสัญญาณว่าคุณข้ามระบบป้องกันความปลอดภัย ณ จุดนั้น

ตัวดำเนินการนี้มีไว้สำหรับกรณีที่พบไม่บ่อย ซึ่งคุณรู้ข้อมูลมากกว่าคอมไพเลอร์จริง ๆ

โดยทั่วไปการเรียกแบบปลอดภัยดีกว่า

ในสถานการณ์ส่วนใหญ่ การเรียกแบบปลอดภัย ?. ร่วมกับเอลวิส ?: จะปลอดภัยกว่าและสั้นพอ ๆ กัน

ลองเปรียบเทียบแนวทางทั้งสองด้านล่างเพื่อบรรลุเป้าหมายเดียวกัน

fun main() {
    val name: String? = null
    val safeLength = name?.length ?: 0
    println(safeLength)
}

หลีกเลี่ยงการต่อ !!

อย่าต่อตัวดำเนินการ !! หลายตัวเข้าด้วยกัน เช่น a!!.b!!.c หากเกิดข้อผิดพลาด คุณจะบอกไม่ได้ว่าส่วนใดเป็นค่าว่าง

แยกนิพจน์ออกเป็นส่วน ๆ หรือใช้การเรียกแบบปลอดภัยแทน

fun main() {
    val text: String? = "hi"
    // bad style: text!!.uppercase()!! is hard to debug
    val good = text?.uppercase() ?: ""
    println(good)
}

กรณีการใช้งานที่เหมาะสม

กรณีหนึ่งที่ยอมรับได้คือค่าที่คุณกำหนดไว้ก่อนหน้านี้และทราบว่าถูกกำหนดค่าเริ่มต้นแล้วในตอนนี้

ถึงอย่างนั้น หากเป็นไปได้ ควรเลือกใช้ lateinit หรือปรับโครงสร้างใหม่

fun main() {
    var config: String? = null
    config = "loaded"
    // we just assigned it, so !! is safe here
    println(config!!.uppercase())
}

การอ่านร่องรอยสแตก

เมื่อ !! ทำงานล้มเหลว ข้อยกเว้นจะชี้ไปยังบรรทัดที่แน่นอน ความแม่นยำนี้เป็นข้อดีเพียงอย่างเดียวเมื่อเทียบกับการได้ผลลัพธ์ที่ผิดโดยไม่แจ้งให้ทราบ

ใช้ข้อความนั้นเพื่อค้นหาและแก้ไขสมมติฐานที่ไม่ถูกต้อง

fun length(text: String?): Int {
    return text!!.length
}

fun main() {
    println(length("abc"))
    // length(null) would throw on the !! line
}

ปรับโครงสร้างเพื่อลบ !!

!! ส่วนใหญ่สามารถลบออกได้ด้วยการจัดการค่าว่างอย่างถูกต้อง ด้านล่างนี้ ค่าสำรองจากเอลวิสทำให้ฟังก์ชันครอบคลุมทุกกรณีและไม่ทำงานล้มเหลว

fun length(text: String?): Int {
    return text?.length ?: 0
}

fun main() {
    println(length("abc"))
    println(length(null))
}

หลักทั่วไป

มอง !! ทุกตัวเป็นคำถามว่า ฉันแน่ใจอย่างยิ่งหรือไม่ว่านี่จะไม่เป็นค่าว่าง

หากแน่ใจและเกิดขึ้นไม่บ่อย → ยอมรับได้
หากไม่แน่ใจ → ใช้ ?. และ ?:

สรุปรวม

ตัวดำเนินการ !! เป็นเครื่องมือที่ทรงพลังแต่ต้องใช้อย่างระมัดระวัง:

บังคับค่าที่เป็นค่าว่างได้ให้เป็นชนิดที่ไม่เป็นค่าว่าง
โยน NullPointerException หากค่านั้นเป็นค่าว่าง
ควรเลือกใช้การเรียกแบบปลอดภัยและเอลวิสในเกือบทุกกรณี

fun main() {
    val sure: String? = "definitely here"
    println(sure!!.length)
    val maybe: String? = null
    println(maybe?.length ?: -1)
}

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

ทดสอบความเข้าใจของคุณเกี่ยวกับตัวดำเนินการยืนยันว่าไม่เป็นค่าว่าง

ทบทวน

คุณได้เรียนรู้เกี่ยวกับตัวดำเนินการ !!:

ยืนยันว่าค่าที่เป็นค่าว่างได้ไม่ใช่ค่าว่าง
โยน NullPointerException เมื่อสมมติฐานไม่ถูกต้อง
ควรใช้เป็นทางเลือกสุดท้าย ไม่ใช่สิ่งที่ทำจนเป็นนิสัย

ถัดไป คุณจะได้เรียนรู้ว่าความสามารถในการเป็นค่าว่างได้มาจาก Java ผ่านชนิดแพลตฟอร์มอย่างไร

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

บทเรียน “ตัวดำเนินการ !!” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “ตัวดำเนินการ !!”

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

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

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

บทเรียน “ตัวดำเนินการ !!” ใช้เวลานานแค่ไหน

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

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

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

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

← กลับไปที่ Kotlin Academy