Kotlin Academy · บทเรียน

ชื่อแทนชนิดข้อมูล

ตั้งชื่อให้ชนิดข้อมูลที่ซับซ้อน

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

นามแฝงชนิดข้อมูลคืออะไร

นามแฝงชนิดข้อมูลจะกำหนดชื่อใหม่ให้ชนิดข้อมูลที่มีอยู่แล้ว ไม่ได้สร้างชนิดใหม่ แต่เป็นเพียงเครื่องมือช่วยให้อ่านง่าย ซึ่งจะถูกแก้ไขขณะคอมไพล์

คุณประกาศนามแฝงชนิดข้อมูลด้วยคีย์เวิร์ด typealias

typealias Name = String

fun main() {
    val n: Name = "Alice"
    println(n)
}

การตั้งชื่อชนิดฟังก์ชัน

ชนิดฟังก์ชันอาจเขียนยืดยาว นามแฝงช่วยให้ลายเซ็นอ่านได้ง่ายขึ้นมาก

typealias Handler = (String) -> Unit

fun register(h: Handler) {
    h("event fired")
}

fun main() {
    register { msg -> println(msg) }
}

การตั้งชื่อชนิดเจเนริก

ชนิดเจเนริกที่ซ้อนกันหลายชั้น เช่น Map<String, List<Int>> จะอ่านได้ดีขึ้นเมื่อใช้นามแฝง

typealias ScoreBoard = Map<String, List<Int>>

fun main() {
    val board: ScoreBoard = mapOf("team1" to listOf(10, 20))
    println(board)
}

นามแฝงไม่ปกปิดชนิดเดิม

เนื่องจากนามแฝงเป็นชนิดเดียวกัน ค่าจึงใช้แทนกันได้อย่างสมบูรณ์ Name และ String สามารถใช้ปะปนกันได้โดยไม่ต้องแปลงค่า

typealias Name = String

fun shout(s: String) = s.uppercase()

fun main() {
    val n: Name = "bob"
    println(shout(n))
}

นามแฝงที่มีพารามิเตอร์

นามแฝงชนิดข้อมูลสามารถมีพารามิเตอร์ชนิดข้อมูลของตนเอง และส่งต่อพารามิเตอร์เหล่านั้นไปยังชนิดพื้นฐานได้

typealias Pairs<T> = List<Pair<T, T>>

fun main() {
    val data: Pairs<Int> = listOf(1 to 2, 3 to 4)
    println(data)
}

การตั้งนามแฝงให้คลาสซ้อน

เส้นทางของคลาสซ้อนหรือคลาสภายในที่ยาวสามารถใช้นามแฝงสั้น ๆ ได้ ช่วยลดความรกจากการนำเข้าและโค้ดที่ไม่จำเป็น

class Outer {
    class Inner {
        fun hello() = "inner hello"
    }
}

typealias Shortcut = Outer.Inner

fun main() {
    println(Shortcut().hello())
}

ปรับปรุงความอ่านง่ายของโดเมน

นามแฝงช่วยสื่อเจตนา typealias UserId = Int บอกว่าเลขจำนวนเต็มใช้แทนตัวตนของผู้ใช้ แม้ว่าคอมไพเลอร์จะยังถือว่าเป็น Int ก็ตาม

typealias UserId = Int
typealias Email = String

fun notify(id: UserId, to: Email) {
    println("Notify user " + id + " at " + to)
}

fun main() {
    notify(42, "a@b.com")
}

ไม่ได้เพิ่มความปลอดภัยด้านชนิดข้อมูล

โปรดทราบว่า เนื่องจากนามแฝงไม่ปกปิดชนิดเดิม คอมไพเลอร์จะไม่ป้องกันไม่ให้คุณส่ง UserId ในตำแหน่งที่ต้องการนามแฝง Int อื่น นามแฝงมีไว้เพื่อการอธิบาย ไม่ใช่การบังคับใช้

typealias UserId = Int
typealias OrderId = Int

fun process(order: OrderId) = println("order " + order)

fun main() {
    val user: UserId = 5
    process(user) // compiles fine — both are Int
}

เฉพาะระดับบนสุด

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

typealias Callback = () -> Unit

fun run(cb: Callback) = cb()

fun main() {
    run { println("done") }
}

ควรใช้นามแฝงเมื่อใด

ควรเลือกใช้นามแฝงชนิดข้อมูลเมื่อ:

ชนิดฟังก์ชันหรือชนิดเจเนริกยาวและปรากฏซ้ำ
ต้องการชื่อของชนิดพื้นฐานที่อธิบายตัวเองได้
ต้องการชื่อสั้น ๆ สำหรับชนิดที่ซ้อนกัน

เมื่อจำเป็นต้องมีความปลอดภัยด้านชนิดข้อมูลอย่างแท้จริง ให้ใช้คลาสค่าแทน

นามแฝงเทียบกับคลาสค่า

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

ตรวจสอบความเข้าใจอย่างรวดเร็ว

ทดสอบความเข้าใจเกี่ยวกับนามแฝงชนิดข้อมูลของคุณ

ทบทวน

คุณได้เรียนรู้นามแฝงชนิดข้อมูล:

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

ถัดไป: คลาสค่าแบบแทรกในโค้ดสำหรับการห่อหุ้มที่ไม่มีค่าใช้จ่ายเพิ่ม

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

บทเรียน “ชื่อแทนชนิดข้อมูล” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “ชื่อแทนชนิดข้อมูล”

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

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

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

บทเรียน “ชื่อแทนชนิดข้อมูล” ใช้เวลานานแค่ไหน

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

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

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

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

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