Kotlin Academy · บทเรียน

การดำเนินการแบบขี้เกียจ

หลีกเลี่ยงรายการระหว่างทาง

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

การดำเนินการแบบประเมินผลเมื่อจำเป็น

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

ไม่มีลิสต์ระหว่างทาง

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

fun main() {
    val result = (1..6).asSequence()
        .map { it * it }
        .filter { it % 2 == 0 }
        .toList()
    println(result)
}

สังเกตการประเมินผลเมื่อจำเป็น

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

fun main() {
    val pipeline = (1..3).asSequence()
        .map { println("map $it"); it }
    println("Built pipeline, nothing ran")
    pipeline.toList()
}

take จำกัดการทำงาน

take(n) เป็นการดำเนินการระหว่างทางแบบประเมินผลเมื่อจำเป็น เมื่อใช้ร่วมกับตัวสร้างที่ไม่มีที่สิ้นสุด การทำงานจะหยุดหลังจากสร้างองค์ประกอบได้ n รายการ

fun main() {
    val firstThree = generateSequence(1) { it + 1 }
        .map { it * 10 }
        .take(3)
        .toList()
    println(firstThree)
}

first หยุดการทำงานทันที

การดำเนินการปลายทางอย่าง first จะหยุดทันทีที่ได้สิ่งที่ต้องการ และข้ามองค์ประกอบที่เหลือทั้งหมด

fun main() {
    val result = (1..1000).asSequence()
        .map { println("processing $it"); it }
        .first { it > 3 }
    println("Found $result")
}

การส่งข้อมูลทีละองค์ประกอบ

ในซีเควนซ์ องค์ประกอบที่ 1 จะผ่าน map แล้วจึงผ่าน filter จากนั้นจึงเป็นองค์ประกอบที่ 2 และทำเช่นนี้ต่อไป ลำดับนี้ทำให้สามารถหยุดการทำงานก่อนครบได้และไม่ต้องเก็บผลลัพธ์ทั้งหมดไว้ชั่วคราว

fun main() {
    listOf(1, 2, 3, 4).asSequence()
        .filter { println("filter $it"); it % 2 == 0 }
        .map { println("map $it"); it * 10 }
        .toList()
}

takeWhile และ dropWhile

takeWhile จะส่งคืนองค์ประกอบไปเรื่อย ๆ จนกว่าเงื่อนไขตรวจสอบจะเป็นเท็จ ส่วน dropWhile จะข้ามองค์ประกอบที่อยู่ต้นลำดับตราบใดที่เงื่อนไขตรวจสอบยังเป็นจริง ทั้งสองแบบประเมินผลเมื่อจำเป็น

fun main() {
    val nums = generateSequence(1) { it + 1 }
    println(nums.takeWhile { it < 5 }.toList())
}

หลีกเลี่ยงการคำนวณที่สูญเปล่า

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

fun main() {
    val result = (1..100).asSequence()
        .map { it * 2 }
        .filter { it > 10 }
        .take(2)
        .toList()
    println(result)
}

การนำซีเควนซ์กลับมาใช้ซ้ำ

ซีเควนซ์ส่วนใหญ่สามารถวนซ้ำได้หลายครั้ง โดยสายการประมวลผลจะทำงานใหม่ทุกครั้ง แต่ซีเควนซ์จากแหล่งข้อมูลที่ใช้ได้เพียงครั้งเดียว เช่น ตัววนซ้ำ จะถูกดึงข้อมูลไปใช้ได้เพียงครั้งเดียว โปรดคำนึงถึงแหล่งข้อมูลด้วย

fun main() {
    val seq = sequenceOf(1, 2, 3).map { it * 2 }
    println(seq.toList())
    println(seq.sum())
}

การดำเนินการมีสถานะและไร้สถานะ

การดำเนินการส่วนใหญ่ไร้สถานะ โดยประมวลผลทีละองค์ประกอบ การดำเนินการบางอย่าง เช่น sorted หรือ distinct มีสถานะและต้องเก็บข้อมูลไว้ชั่วคราวหรือสแกนองค์ประกอบทั้งหมด จึงลดประโยชน์จากการประเมินผลเมื่อจำเป็น

fun main() {
    val result = sequenceOf(3, 1, 2, 1).distinct().sorted().toList()
    println(result)
}

ประโยชน์จากการประเมินผลเมื่อจำเป็น

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

ตรวจสอบอย่างรวดเร็ว

ฟังก์ชันแลมบ์ดาในสายการเรียกใช้ซีเควนซ์จะเริ่มทำงานจริงเมื่อใด

ทบทวน

การดำเนินการแบบประเมินผลเมื่อจำเป็นจะสร้างสายการประมวลผลที่ทำงานก็ต่อเมื่อการดำเนินการปลายทางดึงข้อมูลไปใช้ จึงหลีกเลี่ยงลิสต์ระหว่างทางและทำให้หยุดการทำงานก่อนครบได้ด้วย first, take และ takeWhile โปรดระวังการดำเนินการที่มีสถานะ เช่น sorted ต่อไปคุณจะได้ตัดสินใจว่าเมื่อใดซีเควนซ์เหมาะสมกว่าคอลเลกชัน

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

บทเรียน “การดำเนินการแบบขี้เกียจ” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การดำเนินการแบบขี้เกียจ” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ 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