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

ส่วนขยายตามขอบเขตและส่วนขยายของ Companion

จำกัดการมองเห็นของส่วนขยายและเพิ่มส่วนขยายให้ companion object

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

เหตุใดจึงต้องกำหนดขอบเขตให้ส่วนขยาย

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

ส่วนขยายที่เป็นส่วนตัวระดับไฟล์

ทำเครื่องหมายฟังก์ชันส่วนขยายด้วย private ที่ระดับไฟล์ เพื่อจำกัดให้ใช้ได้เฉพาะในไฟล์นั้น

private fun String.shout() = uppercase() + "!"
fun main() {
    println("hello".shout()) // HELLO!
}

การมองเห็นภายใน

ใช้ internal เพื่อจำกัดส่วนขยายให้อยู่เฉพาะในโมดูลปัจจุบัน เหมาะสำหรับส่วนภายในของไลบรารีที่ไม่ได้ตั้งใจให้ภายนอกใช้งาน

internal fun List<Int>.sumIfPositive(): Int = filter { it > 0 }.sum()
fun main() {
    println(listOf(-1, 2, 3, -4).sumIfPositive()) // 5
}

ฟังก์ชันส่วนขยายสมาชิก

ประกาศส่วนขยาย ภายในคลาส เพื่อให้ใช้ได้เฉพาะเมื่ออินสแตนซ์ของคลาสนั้นอยู่ในขอบเขต ฟังก์ชันนี้มีผู้รับสองรายการ ได้แก่ ผู้รับการจัดส่ง (คลาส) และผู้รับส่วนขยาย (เป้าหมาย)

class StringHelper(val prefix: String) {
    fun String.withPrefix() = prefix + this
    fun build(): String = "world".withPrefix() // calls extension via instance
}
fun main() {
    println(StringHelper("hello ").build()) // hello world
}

การมองเห็นของส่วนขยายสมาชิก

ส่วนขยายสมาชิกไม่สามารถเข้าถึงได้จากภายนอกคลาสผู้รับการจัดส่ง จึงมีประโยชน์สำหรับการห่อหุ้ม

class Repo {
    fun List<Int>.allPositive() = all { it > 0 }
    fun check(xs: List<Int>) = xs.allPositive()
}
fun main() {
    val r = Repo()
    println(r.check(listOf(1, 2, 3))) // true
    // listOf(1).allPositive() // ERROR — no access
}

ส่วนขยายบนอ็อบเจ็กต์คู่หู

เพิ่มส่วนขยายให้กับอ็อบเจ็กต์คู่หูของคลาส ผู้เรียกจะมองเห็นคล้ายเมธอดสแตติก แต่ส่วนขยายอยู่ภายนอกคลาส

class Greeter {
    companion object
}
fun Greeter.Companion.morning() = "Good morning!"
fun main() {
    println(Greeter.morning())
}

เหตุใดจึงใช้ส่วนขยายของอ็อบเจ็กต์คู่หู

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

class User(val name: String) {
    companion object
}
fun User.Companion.guest() = User("Guest")
fun User.Companion.system() = User("System")
fun main() {
    println(User.guest().name)
    println(User.system().name)
}

ต้องมีอ็อบเจ็กต์คู่หูที่ว่างเปล่า

คลาสต้อง ประกาศอ็อบเจ็กต์คู่หู (แม้จะว่างเปล่า) เพื่อให้ส่วนขยายของอ็อบเจ็กต์คู่หูเชื่อมต่อได้ มิฉะนั้นจะไม่มีเป้าหมายของส่วนขยาย

class Box {
    companion object // required, even if empty
}
fun Box.Companion.create(): Box = Box()
fun main() {
    println(Box.create())
}

ส่วนขยายแบบกำหนดขอบเขตผ่านการนำเข้า

คุณสามารถกำหนดขอบเขตการใช้ส่วนขยายได้ด้วยการนำเข้าส่วนขยายเฉพาะในไฟล์ที่ต้องการ ไฟล์ที่ไม่ได้นำเข้าจะมองไม่เห็นส่วนขยายนั้น

// File A:
// fun String.shout() = uppercase()
// File B imports:
// import com.example.shout
// Only File B can call shout()
fun String.shout() = uppercase() + "!"
fun main() { println("hi".shout()) }

ฟังก์ชันส่วนขยายผ่านฟังก์ชันกำหนดขอบเขต

ใช้ with หรือ apply เพื่อดึงอ็อบเจ็กต์เข้ามาอยู่ในขอบเขตชั่วคราวสำหรับใช้ส่วนขยาย

class StringTools {
    fun String.greet() = "Hello, $this!"
    fun process(name: String) = with(this) {
        name.greet()
    }
}
fun main() {
    println(StringTools().process("Ada"))
}

พร็อพเพอร์ตีส่วนขยายบนออบเจ็กต์ร่วม

ส่วนขยายของออบเจ็กต์ร่วมสามารถเป็นพร็อพเพอร์ตีได้เช่นกัน — ให้เพิ่มค่าคงที่ที่มีชื่อจากภายนอกคลาส

class HttpStatus {
    companion object
}
val HttpStatus.Companion.OK_CODE: Int get() = 200
val HttpStatus.Companion.NOT_FOUND: Int get() = 404
fun main() {
    println(HttpStatus.OK_CODE)
    println(HttpStatus.NOT_FOUND)
}

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

ใช้ private สำหรับตัวช่วยภายในไฟล์ ใช้ internal สำหรับ API ที่ใช้ได้เฉพาะภายในโมดูล ใช้ส่วนขยายสมาชิกเพื่อการห่อหุ้ม และใช้ส่วนขยายของออบเจ็กต์ร่วมเพื่อเพิ่มตัวช่วยลักษณะเดียวกับตัวสร้างจากภายนอก

class StringUtils {
    companion object
}
fun StringUtils.Companion.isAlpha(s: String) = s.all { it.isLetter() }
fun main() {
    println(StringUtils.isAlpha("hello"))
    println(StringUtils.isAlpha("hi5"))
}

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

คลาสต้องมีอะไรจึงจะสามารถเพิ่ม ส่วนขยายของออบเจ็กต์ร่วม ให้คลาสนั้นจากภายนอกได้

สรุปทบทวน

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

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

บทเรียน “ส่วนขยายตามขอบเขตและส่วนขยายของ Companion” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “ส่วนขยายตามขอบเขตและส่วนขยายของ Companion”

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

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

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

บทเรียน “ส่วนขยายตามขอบเขตและส่วนขยายของ Companion” ใช้เวลานานแค่ไหน

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

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

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

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

  1. ฟังก์ชันส่วนขยาย: ไวยากรณ์และกฎการเลือกใช้
  2. พร็อพเพอร์ตีส่วนขยายและส่วนขยายแบบคำนวณค่า
  3. ส่วนขยายตามขอบเขตและส่วนขยายของ Companion
  4. ส่วนขยายเชิงปฏิบัติ: ตัวช่วย Context, View และ String
← กลับไปที่ Kotlin Academy