การดึงและกรองแบบขี้เกียจ
ตัดแบ่งสตรีมไม่สิ้นสุด
การดึงและกรองแบบขี้เกียจ เป็นบทเรียน Scala for Backend Engineering & Functional Programming ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Scala for Backend Engineering & Functional Programming และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Scala for Backend Engineering & Functional Programming มีบทเรียนทั้งหมด 4 บทเรียน
การประมวลผลแบบขี้เกียจ
คุณค่าที่แท้จริงของ LazyList จะแสดงออกมาเมื่อคุณเรียกใช้ การดำเนินการอย่าง take, filter และ map ยังคงทำงานแบบขี้เกียจ โดยคำนวณเฉพาะเซลล์ที่คุณบังคับให้สร้างในท้ายที่สุด
บทนี้ครอบคลุมตัวแปลงสำคัญและวิธีหยุดการทำงานแบบขี้เกียจในจังหวะที่เหมาะสม
take(n)
take(n) คืนค่า LazyList ที่มีองค์ประกอบไม่เกิน n รายการแรก และตัวมันเองยังคงทำงานแบบขี้เกียจ จะยังไม่มีการคำนวณใด ๆ จนกว่าคุณจะบังคับให้ประเมินผลลัพธ์
นี่เป็นวิธีที่ปลอดภัยในการจำกัดขอบเขตของกระแสข้อมูลที่ไม่มีที่สิ้นสุด
object Demo extends App {
val first5 = LazyList.from(1).take(5)
println(first5.toList)
}takeWhile
takeWhile(p) จะคืนค่าองค์ประกอบตราบใดที่เพรดิเคตเป็นจริง แล้วหยุดที่ความล้มเหลวครั้งแรก
สำหรับกระแสข้อมูลที่ไม่มีที่สิ้นสุด นี่เป็นเงื่อนไขหยุดที่ชัดเจนโดยไม่จำเป็นต้องทราบจำนวนองค์ประกอบ
object Demo extends App {
val small = LazyList.from(1).takeWhile(_ < 6)
println(small.toList)
}drop และ dropWhile
drop(n) ข้ามองค์ประกอบ n รายการแรก ส่วน dropWhile(p) จะข้ามไปตราบใดที่เพรดิเคตเป็นจริง ทั้งคู่คืนส่วนที่เหลือซึ่งยังทำงานแบบขี้เกียจ
ใช้เพื่อเลื่อนไปยังตำแหน่งที่ต้องการในกระแสข้อมูลก่อนดึงช่วงข้อมูลออกมา
object Demo extends App {
val rest = LazyList.from(1).drop(3).take(3)
println(rest.toList)
}การกรองแบบขี้เกียจ
filter บน LazyList ทำงานแบบขี้เกียจ โดยจะทดสอบองค์ประกอบเมื่อผู้บริโภคปลายทางดึงข้อมูลเท่านั้น
เมื่อใช้ร่วมกับ take โปรแกรมจะประมวลผลองค์ประกอบต้นทางเท่าที่จำเป็นต่อความต้องการพอดี ไม่มากกว่านั้น
object Demo extends App {
val evens = LazyList.from(1).filter(_ % 2 == 0)
println(evens.take(4).toList)
}ดูความต้องการข้อมูล
เพิ่มคำสั่งพิมพ์ไว้ในเพรดิเคตเพื่อดูว่ามีองค์ประกอบเพียงไม่กี่รายการที่ถูกทดสอบ ตัวกรองจะทำงานจนกว่า take จะได้ข้อมูลครบตามต้องการเท่านั้น
เรียกใช้โค้ดนี้: จำนวนบรรทัด "check" จะแสดงการประเมินผลตามความต้องการ ไม่ใช่การประเมินทั้งกระแสข้อมูล
object Demo extends App {
val r = LazyList.from(1).filter { n =>
println("check " + n); n % 3 == 0
}
println(r.take(2).toList)
}เชื่อมต่อ map และ filter
คุณสามารถเชื่อมต่อตัวแปลงหลายตัวได้ โดยกระบวนการทั้งหมดจะยังคงทำงานแบบขี้เกียจและรวมการทำงานเป็นรายองค์ประกอบ องค์ประกอบต้นทางแต่ละรายการจะไหลผ่าน map แล้วจึงผ่าน filter เมื่อมีการดึงข้อมูลเท่านั้น
จะไม่มีการสร้างคอลเลกชันเต็มชุดชั่วคราว
object Demo extends App {
val r = LazyList.from(1).map(_ * _).filter(_ > 10).take(3)
println(r.toList)
}find: หยุดแต่เนิ่น ๆ
find(p) คืนค่าองค์ประกอบแรกที่ตรงเงื่อนไขในรูป Option โดยบังคับประเมินผลเพียงจนถึงองค์ประกอบนั้น จึงเหมาะอย่างยิ่งสำหรับค้นหาในกระแสข้อมูลที่ไม่มีที่สิ้นสุด
เมื่อพบรายการที่ตรงเงื่อนไข การประเมินผลจะหยุดทันที
object Demo extends App {
val firstBig = LazyList.from(1).find(_ * _ > 50)
println(firstBig)
}headOption และ exists
headOption ใช้ดูองค์ประกอบแรกอย่างปลอดภัย ส่วน exists(p) จะบังคับประเมินผลจนกว่าจะพบรายการที่ตรงเงื่อนไข (หรือทำต่อไปเรื่อย ๆ หากไม่พบ) ใช้ exists กับกระแสข้อมูลที่ไม่มีที่สิ้นสุดเฉพาะเมื่อรับประกันว่าจะพบรายการที่ตรงเงื่อนไข
ทั้งคู่จะหยุดให้เร็วที่สุด
object Demo extends App {
val has = LazyList.from(1).exists(_ == 7)
println(has)
}บังคับให้ได้ผลลัพธ์
ตัวแปลงแบบขี้เกียจใช้เพื่ออธิบายงาน ส่วนการดำเนินการปลายทางจะเป็นผู้บังคับให้ทำงานจริง toList, foreach, sum และ foldLeft จะใช้กระแสข้อมูลที่จำกัดขอบเขตแล้วและสร้างค่าเป็นรูปธรรม
ต้องจำกัดขอบเขตกระแสข้อมูลที่ไม่มีที่สิ้นสุดก่อนใช้การดำเนินการปลายทางที่ต้องใช้ข้อมูลทั้งหมดเสมอ
object Demo extends App {
val total = LazyList.from(1).take(100).sum
println(total)
}ข้อควรระวังเมื่อกรองข้อมูล
filter ที่ไม่พบรายการใดเลยจะทำให้ take ที่จำกัดขอบเขตกลายเป็นการค้นหาที่ไม่มีที่สิ้นสุด LazyList.from(1).filter(_ < 0).take(1) จะค้างอยู่ตลอดไป
ตรวจสอบให้แน่ใจว่าเพรดิเคตสามารถเป็นจริงได้ หรือใช้ตัวกรองร่วมกับ takeWhile เพื่อรับประกันว่าการทำงานจะสิ้นสุด
ตรวจสอบความเข้าใจ
ตรวจสอบความเข้าใจของคุณเกี่ยวกับการใช้ข้อมูลแบบขี้เกียจ
สรุปทบทวน
take, takeWhile, drop, filter และ map ยังคงทำงานแบบขี้เกียจและรวมการทำงานเป็นรายองค์ประกอบ ส่วน find, exists และ headOption จะหยุดแต่เนิ่น ๆ ขณะที่การดำเนินการปลายทางอย่าง toList และ sum จะบังคับให้ประเมินผลลัพธ์
ระวังตัวกรองที่ไม่มีทางเป็นจริงบนกระแสข้อมูลที่ไม่มีที่สิ้นสุด ตอนนี้คุณสามารถสร้างและใช้ลำดับแบบขี้เกียจได้อย่างมั่นใจ
เรียนรู้ Scala ด้วย AI tutor — ฟรี
เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป
- คอร์ส
- 39
- บทเรียน
- 143
คำถามที่พบบ่อย
บทเรียน “การดึงและกรองแบบขี้เกียจ” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “การดึงและกรองแบบขี้เกียจ” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Scala for Backend Engineering & Functional Programming ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Scala for Backend Engineering & Functional Programming มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “การดึงและกรองแบบขี้เกียจ”
ตัดแบ่งสตรีมไม่สิ้นสุด คุณปฏิบัติ Scala for Backend Engineering & Functional Programming ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Scala for Backend Engineering & Functional Programming หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Scala for Backend Engineering & Functional Programming บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน
บทเรียน “การดึงและกรองแบบขี้เกียจ” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Scala for Backend Engineering & Functional Programming นี้ได้ไหม
ได้ บทเรียน Scala for Backend Engineering & Functional Programming ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- อธิบายการประเมินแบบขี้เกียจ
- สร้าง LazyList
- สตรีมไม่สิ้นสุด
- การดึงและกรองแบบขี้เกียจ