Android Academy · บทเรียน

หลีกเลี่ยง NullPointerExceptions

รูปแบบสำหรับโค้ดที่ปลอดภัย

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

เป้าหมาย: ไม่มี NPE

NullPointerException หรือ NPE เกิดขึ้นเมื่อโค้ดใช้งานสิ่งที่มีค่าเป็นค่าว่างจริง ๆ Kotlin ได้รับการออกแบบมาเพื่อลดโอกาสเกิดปัญหานี้

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

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

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

ตัวดำเนินการนี้จะลบความปลอดภัยออกไป จึงควรใช้ให้น้อยและใช้เฉพาะเมื่อคุณแน่ใจเท่านั้น

fun main() {
    val name: String? = "Ada"
    println(name!!.length)  // works, name is not null
}

!! อาจทำให้โปรแกรมหยุดทำงาน

หากค่าเป็นค่าว่างจริง !! จะโยน NullPointerException ที่บรรทัดนั้นพอดี

นี่เป็นวิธีหลักที่ทำให้ปัญหาซึ่ง Kotlin ป้องกันไว้กลับมาเกิดขึ้นอีก หลีกเลี่ยง !! เมื่อสามารถใช้การเรียกใช้อย่างปลอดภัยหรือ Elvis แทนได้

val name: String? = null
println(name!!.length)
// throws KotlinNullPointerException

เลือกทางเลือกที่ปลอดภัยกว่า

การใช้ !! แทบทุกกรณีสามารถเขียนใหม่ด้วย ?. และ ?: ได้ รูปแบบที่ปลอดภัยจะไม่ทำให้โปรแกรมหยุดทำงาน

เปรียบเทียบรูปแบบที่มีความเสี่ยงกับรูปแบบที่ปลอดภัยด้านล่าง

// Risky:
val len1 = name!!.length
// Safe:
val len2 = name?.length ?: 0

ตรวจสอบตั้งแต่เนิ่น ๆ

จัดการค่าว่างที่ขอบเขตของโค้ด แล้วทำงานกับค่าที่ไม่ใช่ค่าว่างภายใน ใช้ Elvis ร่วมกับ return หรือ throw เพื่อปฏิเสธข้อมูลนำเข้าที่ขาดหายไปตั้งแต่ต้น

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

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

requireNotNull

เมื่อค่าว่างหมายถึงข้อผิดพลาดจริง ๆ requireNotNull จะโยนข้อผิดพลาดที่ชัดเจนและคืนค่าที่ไม่ใช่ค่าว่าง

ฟังก์ชันนี้สื่อความหมายได้ดีกว่า !! เพราะคุณสามารถเพิ่มข้อความได้

fun start(config: String?) {
    val c = requireNotNull(config) { "config missing" }
    println(c.length)
}

ประเภทจากแพลตฟอร์มของ Java

ค่าที่มาจาก Java จะมีความสามารถในการเป็นค่าว่างที่ไม่ทราบแน่ชัด ซึ่งเรียกว่าประเภทจากแพลตฟอร์ม Kotlin ไม่สามารถรับประกันได้ว่าค่าเหล่านี้ไม่ใช่ค่าว่าง

เมื่อใช้ไลบรารีของ Java ให้ประกาศประเภทที่คาดไว้โดยชัดเจน และจัดการค่าว่างอย่างรัดกุม

// From Java: String maybe = obj.getName();
val name: String? = obj.name  // be safe
println(name?.length ?: 0)

ข้อควรระวังของ lateinit

lateinit var ช่วยให้คุณเลื่อนการกำหนดค่าเริ่มต้นของพร็อพเพอร์ตี้ที่ไม่ใช่ค่าว่างออกไปได้ แต่หากนำไปใช้ก่อนกำหนดค่า ระบบจะโยนข้อยกเว้น

ใช้ lateinit เฉพาะเมื่อคุณแน่ใจว่าค่าจะถูกกำหนดก่อนการเข้าถึงทุกครั้ง

lateinit var config: String
fun read() {
    println(config.length)
    // crashes if config was never set
}

ใช้ค่าเริ่มต้นแทนค่าว่าง

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

เมื่อมีประเภทที่อาจเป็นค่าว่างน้อยลง โอกาสเกิด NPE ก็ลดลง

fun main() {
    val tags: List<String> = emptyList()
    println(tags.size)  // 0, never null
}

สายการทำงานที่ปลอดภัย

โปรแกรมนี้อ่านค่าทางเลือก แปลงค่าอย่างปลอดภัย และสร้างผลลัพธ์ได้เสมอ ไม่มี !! และไม่มีการหยุดทำงาน

นี่คือรูปแบบที่ควรมุ่งใช้ในโค้ด Android จริง

fun main() {
    val input: String? = null
    val result = input?.trim()?.uppercase() ?: "N/A"
    println(result)  // prints: N/A
}

แนวทางปฏิบัติที่ดี

เลือกใช้ประเภทที่ไม่ใช่ค่าว่าง จัดการค่าว่างที่ขอบเขตด้วย Elvis และใช้ ?.let สำหรับการดำเนินการที่เป็นทางเลือก เก็บ !! ไว้ใช้ในกรณีที่พบได้น้อยและเป็นไปไม่ได้ที่ค่าจะเป็นค่าว่าง

ปฏิบัติตามแนวทางเหล่านี้ แล้ว NullPointerExceptions จะกลายเป็นเรื่องในอดีต

val safe = data?.value ?: default
data?.let { handle(it) }

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

ทดสอบความเข้าใจของคุณเกี่ยวกับการหลีกเลี่ยง NullPointerExceptions

สรุปทบทวน

NPE ใน Kotlin มักเกิดจาก !! ประเภทจากแพลตฟอร์มของ Java หรือค่า lateinit ที่ยังไม่ได้กำหนด หลีกเลี่ยงปัญหาเหล่านี้ด้วยการเลือกใช้ประเภทที่ไม่ใช่ค่าว่างและตัวดำเนินการที่ปลอดภัย

ใช้ ?., ?:, ?.let และการตรวจสอบอย่าง requireNotNull เพื่อให้โค้ดไม่หยุดทำงานจากข้อผิดพลาด ตอนนี้คุณได้เรียนรู้พื้นฐานสำคัญของการป้องกันค่าว่างใน Kotlin ครบแล้ว

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

บทเรียน “หลีกเลี่ยง NullPointerExceptions” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “หลีกเลี่ยง NullPointerExceptions”

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

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

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

บทเรียน “หลีกเลี่ยง NullPointerExceptions” ใช้เวลานานแค่ไหน

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

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

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

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

ชนิดข้อมูลที่อาจเป็นค่าว่างเทียบกับไม่เป็นค่าว่าง
การเรียกอย่างปลอดภัยและ Elvis
ฟังก์ชัน let, also และ scope
หลีกเลี่ยง NullPointerExceptions

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