สร้าง LazyList
สร้างลำดับแบบขี้เกียจ
สร้าง LazyList เป็นบทเรียน Scala for Backend Engineering & Functional Programming ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Scala for Backend Engineering & Functional Programming และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Scala for Backend Engineering & Functional Programming มีบทเรียนทั้งหมด 4 บทเรียน
พื้นฐานการสร้าง
มีหลายวิธีในการสร้าง LazyList วิธีที่ง่ายที่สุดคือโรงงาน apply เช่นเดียวกับการสร้าง List
แต่พลังที่แท้จริงมาจากตัวสร้างที่รักษาส่วนท้ายให้เป็นแบบขี้เกียจ ซึ่งเราจะสำรวจในบทเรียนนี้
val ll = LazyList(10, 20, 30)
println(ll.head)LazyList ว่าง
LazyList.empty คือตัวสิ้นสุด ซึ่งเทียบเท่ากับ Nil ในรูปแบบขี้เกียจ LazyList แบบมีขอบเขตทุกตัวจะลงท้ายด้วยสิ่งนี้
คุณใช้มันเป็นกรณีฐานเมื่อนำสมาชิกมาเติมด้านหน้าด้วย #::
object Demo extends App {
val empty = LazyList.empty[Int]
println(empty.isEmpty)
println(empty.toList)
}การเติมด้านหน้าด้วย #::
ตัวดำเนินการ #:: จะ cons ส่วนหัวเข้ากับส่วนท้ายแบบ by-name สร้างลิสต์จากขวาไปซ้าย โดยลงท้ายด้วย LazyList.empty
เนื่องจาก #:: รับส่วนท้ายแบบขี้เกียจ สิ่งที่อยู่ถัดจากส่วนหัวจึงยังไม่ถูกสร้างจนกว่าจะถูกบังคับให้ประเมิน
object Demo extends App {
val ll = 1 #:: 2 #:: 3 #:: LazyList.empty
println(ll.toList)
}สังเกตความขี้เกียจ
ใส่ผลข้างเคียงไว้ในส่วนท้ายเพื่อดูว่ามันทำงานเมื่อใด การบังคับให้ประเมินส่วนท้ายเท่านั้นที่จะทำให้ผลข้างเคียงทำงาน
เรียกใช้โค้ดนี้: "กำลังสร้างส่วนท้าย" จะถูกพิมพ์หลังจากเข้าถึงสมาชิกตัวที่สองเท่านั้น ไม่ใช่ตอนที่กำหนด LazyList
object Demo extends App {
val ll = 1 #:: { println("building tail"); 2 #:: LazyList.empty }
println("defined")
println(ll.head)
println(ll(1))
}ใช้ cons อย่างชัดเจน
ภายใต้การทำงาน #:: คือ LazyList.cons ทั้งส่วนหัวและส่วนท้ายเป็นแบบ by-name ใน cons ทำให้ควบคุมการประเมินค่าได้อย่างเต็มที่
สิ่งนี้มีประโยชน์เมื่อกำหนดตัวสร้างแบบเรียกซ้ำ
val ll = LazyList.cons(1, LazyList.cons(2, LazyList.empty))
println(ll.head)ตัวสร้างแบบเรียกซ้ำ
LazyList สามารถอ้างอิงถึงตัวมันเองได้ ให้กำหนดฟังก์ชันที่สร้างส่วนหัวและเรียกตัวมันเองซ้ำเพื่อสร้างส่วนท้าย
เนื่องจากส่วนท้ายเป็นแบบ by-name การเรียกซ้ำจึงไม่ทำงานไม่รู้จบ แต่จะหยุดรอจนกว่าแต่ละเซลล์จะถูกเรียกใช้
def countFrom(n: Int): LazyList[Int] =
n #:: countFrom(n + 1)
println(countFrom(5).take(3).toList)การเรียกใช้ตัวสร้าง
มาลองเรียกใช้ตัวสร้างที่อ้างอิงถึงตัวเองและดึงค่าบางส่วนออกมา take จะจำกัดจำนวนเซลล์ที่ถูกบังคับให้ประเมิน
หากไม่มี take การทำงานนี้จะวนไม่รู้จบ ดังนั้นต้องกำหนดขอบเขตให้ตัวสร้างอนันต์ก่อนบังคับให้ประเมินเสมอ
object Demo extends App {
def countFrom(n: Int): LazyList[Int] =
n #:: countFrom(n + 1)
println(countFrom(1).take(5).toList)
}จากตัววนซ้ำ
คุณสามารถห่อหุ้มคอลเลกชันหรือตัววนซ้ำที่มีอยู่ได้ LazyList.from(start) จะสร้างการนับแบบอนันต์ และ someList.to(LazyList) จะแปลงข้อมูลที่ทราบอยู่แล้วอย่างกระตือรือร้น
สิ่งเหล่านี้ให้มุมมองแบบขี้เกียจเหนือข้อมูลที่คุณมีอยู่หรือสามารถอธิบายได้
object Demo extends App {
val ll = List(1, 2, 3).to(LazyList)
println(ll.map(_ * 2).toList)
}LazyList.iterate
LazyList.iterate(seed)(f) จะใช้ f ซ้ำ ๆ เพื่อสร้างสมาชิกถัดไปจากสมาชิกก่อนหน้า
นี่เป็นวิธีที่ชัดเจนในการอธิบายลำดับที่กำหนดด้วยกฎการเปลี่ยนค่า เช่น เลขยกกำลังสอง
object Demo extends App {
val powers = LazyList.iterate(1)(_ * 2)
println(powers.take(6).toList)
}LazyList.continually
LazyList.continually(expr) จะทำซ้ำนิพจน์อย่างไม่สิ้นสุด โดยประเมินนิพจน์ใหม่สำหรับสมาชิกแต่ละตัว เหมาะสำหรับกระแสค่าคงที่หรือค่าที่สุ่ม
ใช้ร่วมกับ take เพื่อดึงช่วงข้อมูลที่มีขอบเขต
object Demo extends App {
val zeros = LazyList.continually(0)
println(zeros.take(4).toList)
}การเลือกตัวสร้าง
ใช้ apply สำหรับลิสต์ขนาดเล็กที่มีจำนวนคงที่ ใช้ #:: หรือ cons สำหรับการเรียกซ้ำที่เขียนด้วยตนเอง ใช้ iterate สำหรับกฎการเปลี่ยนค่า ใช้ from สำหรับการนับ และใช้ continually สำหรับการทำซ้ำ
ทั้งหมดรักษาส่วนท้ายให้เป็นแบบขี้เกียจ ดังนั้นการเลือกจึงขึ้นอยู่กับความเหมาะสมในการอธิบาย
ตรวจสอบความเข้าใจอย่างรวดเร็ว
ตรวจสอบความเข้าใจเกี่ยวกับการสร้าง LazyList
สรุปทบทวน
คุณสร้าง LazyLists ด้วย apply, empty, #::/cons, iterate, from และ continually
ส่วนท้ายแบบ by-name ทำให้สามารถกำหนดตัวสร้างที่อ้างอิงถึงตัวเองและอาจมีจำนวนไม่สิ้นสุดได้อย่างปลอดภัย ถัดไปเราจะใช้แนวคิดนี้เพื่อสร้างกระแสอนันต์อย่างแท้จริง
เรียนรู้ Scala ด้วย AI tutor — ฟรี
เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป
- คอร์ส
- 39
- บทเรียน
- 143
คำถามที่พบบ่อย
บทเรียน “สร้าง LazyList” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “สร้าง LazyList” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Scala for Backend Engineering & Functional Programming ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Scala for Backend Engineering & Functional Programming มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “สร้าง LazyList”
สร้างลำดับแบบขี้เกียจ คุณปฏิบัติ Scala for Backend Engineering & Functional Programming ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Scala for Backend Engineering & Functional Programming หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Scala for Backend Engineering & Functional Programming บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน
บทเรียน “สร้าง LazyList” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Scala for Backend Engineering & Functional Programming นี้ได้ไหม
ได้ บทเรียน Scala for Backend Engineering & Functional Programming ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ