Kotlin Academy · บทเรียน

ชนิด Nullable และ Non-Null

พื้นฐานระบบชนิดข้อมูล

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

เหตุใดความปลอดภัยจากค่าว่างจึงสำคัญ

NullPointerException อันเลื่องชื่อทำให้โปรแกรมจำนวนนับไม่ถ้วนหยุดทำงาน Kotlin แก้ปัญหานี้โดยตรงด้วยการทำให้ความเป็นค่าว่างเป็นส่วนหนึ่งของระบบประเภท

ใน Kotlin คอมไพเลอร์จะรู้ว่าค่าสามารถเป็น null ได้หรือไม่ และบังคับให้คุณจัดการความเป็นไปได้นี้ก่อนที่จะเกิดปัญหา

ประเภทที่ไม่เป็นค่าว่าง

โดยค่าเริ่มต้น ทุกประเภทใน Kotlin จะไม่เป็นค่าว่าง ตัวแปรประเภท String ไม่สามารถเก็บค่า null ได้

การรับประกันนี้ได้รับการตรวจสอบขณะคอมไพล์ ดังนั้นคุณจึงใช้ค่าได้อย่างอิสระโดยไม่ต้องตรวจสอบ

fun main() {
    val name: String = "Alice"
    println(name.length)
}

การกำหนดค่าว่างจะถูกปฏิเสธ

ลองใส่ค่า null ลงในประเภทที่ไม่เป็นค่าว่าง แล้วคอมไพเลอร์จะหยุดคุณทันที

บรรทัดด้านล่างนี้จะคอมไพล์ไม่สำเร็จ เนื่องจาก String ไม่ยอมรับค่า null:

val name: String = null → ข้อผิดพลาด

fun main() {
    val city: String = "Paris"
    // val broken: String = null // compile error
    println(city)
}

ประเภทที่อาจเป็นค่าว่าง

หากต้องการอนุญาตให้เป็น null ให้เติมเครื่องหมายคำถามหลังประเภท: String?

นี่คือประเภทที่อาจเป็นค่าว่าง ซึ่งเก็บได้ทั้งค่าจริงหรือ null

fun main() {
    val maybeName: String? = null
    println(maybeName)
}

ประเภทที่อาจเป็นค่าว่างกับประเภทที่ไม่เป็นค่าว่าง

การประกาศทั้งสองดูเกือบเหมือนกัน แต่มีพฤติกรรมแตกต่างกันมาก:

val a: String → ไม่เป็นค่าว่างเสมอ
val b: String? → อาจเป็นค่าว่าง

เครื่องหมาย ? เพียงตัวเดียวเปลี่ยนข้อกำหนดทั้งหมดของตัวแปร

fun main() {
    val a: String = "hi"
    val b: String? = "hi"
    println(a)
    println(b)
}

คอมไพเลอร์ป้องกันการเข้าถึงค่าที่อาจเป็นค่าว่าง

คุณไม่สามารถเรียกใช้เมธอดกับค่าที่อาจเป็นค่าว่างได้โดยตรง คอมไพเลอร์จะปฏิเสธ เนื่องจากค่านั้นอาจเป็น null

บรรทัดที่มีเครื่องหมายข้อคิดเห็นด้านล่างนี้จะคอมไพล์ไม่สำเร็จ:

maybe.length กับ String? → ข้อผิดพลาด

fun main() {
    val maybe: String? = "text"
    // println(maybe.length) // compile error
    println(maybe)
}

การตรวจสอบค่าว่าง

วิธีง่าย ๆ วิธีหนึ่งในการใช้ค่าที่อาจเป็นค่าว่างคือการตรวจสอบด้วย if อย่างชัดเจน

ภายในบล็อก if Kotlin จะรู้ว่าค่านั้นไม่เป็นค่าว่าง และอนุญาตให้คุณใช้ได้อย่างปลอดภัย

fun main() {
    val maybe: String? = "hello"
    if (maybe != null) {
        println(maybe.length)
    }
}

ค่าว่างในพารามิเตอร์ฟังก์ชัน

ประเภทของพารามิเตอร์ก็ใช้กฎเดียวกัน พารามิเตอร์ประเภท String ต้องได้รับค่าจริง ส่วน String? ยอมรับค่า null

ทำให้ลายเซ็นฟังก์ชันอธิบายได้ด้วยตัวเองว่ารับค่าใดบ้าง

fun greet(name: String?) {
    if (name != null) {
        println("Hello, " + name)
    } else {
        println("Hello, guest")
    }
}

fun main() {
    greet("Mia")
    greet(null)
}

ประเภทค่าที่คืนกลับซึ่งอาจเป็นค่าว่าง

ฟังก์ชันสามารถคืนค่าประเภทที่อาจเป็นค่าว่าง เพื่อสื่อว่าผลลัพธ์อาจไม่มีค่า

จากนั้นผู้เรียกจะถูกบังคับให้จัดการกับความเป็นไปได้ที่จะเป็น null ก่อนใช้ผลลัพธ์

fun firstChar(text: String?): Char? {
    if (text == null || text.isEmpty()) return null
    return text[0]
}

fun main() {
    println(firstChar("Kotlin"))
    println(firstChar(null))
}

การอนุมานประเภทโดยค่าเริ่มต้น

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

val n = "text" → อนุมานเป็น String

หากต้องการให้เป็นประเภทที่อาจเป็นค่าว่าง คุณต้องประกาศประเภทอย่างชัดเจนด้วย ?

fun main() {
    val n = "text" // inferred String (non-null)
    val m: String? = "text" // explicit nullable
    println(n.length)
    println(m)
}

สรุปภาพรวม

ระบบประเภทแบ่งค่าออกเป็นสองกลุ่มอย่างชัดเจน:

ไม่เป็นค่าว่าง: ใช้ได้อย่างปลอดภัยเสมอ
อาจเป็นค่าว่าง: ต้องจัดการก่อนใช้งาน

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

fun main() {
    val safe: String = "always here"
    val risky: String? = null
    println(safe.uppercase())
    if (risky != null) println(risky.uppercase()) else println("no value")
}

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

ทดสอบความเข้าใจเกี่ยวกับประเภทที่อาจเป็นค่าว่างและประเภทที่ไม่เป็นค่าว่าง

สรุป

คุณได้เรียนรู้พื้นฐานของความปลอดภัยจากค่าว่างใน Kotlin แล้ว:

ทุกประเภทไม่เป็นค่าว่างโดยค่าเริ่มต้น
การเพิ่ม ? จะสร้างประเภทที่อาจเป็นค่าว่าง
คอมไพเลอร์จะป้องกันการเข้าถึงค่าที่อาจเป็นค่าว่างอย่างไม่ปลอดภัย
การตรวจสอบ if (x != null) ช่วยให้คุณใช้ค่าได้อย่างปลอดภัย

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

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

บทเรียน “ชนิด Nullable และ Non-Null” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “ชนิด Nullable และ Non-Null”

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

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

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

บทเรียน “ชนิด Nullable และ Non-Null” ใช้เวลานานแค่ไหน

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

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

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

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

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