ตัววนซ้ำแบบขี้เกียจและตัวสร้างด้วย sync*
สร้างค่าตามต้องการ
ตัววนซ้ำแบบขี้เกียจและตัวสร้างด้วย sync* เป็นบทเรียน Dart Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Dart Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Dart Academy มีบทเรียนทั้งหมด 4 บทเรียน
ความหมายของ Lazy
iterable แบบ lazy จะยังไม่คำนวณค่าจนกว่าคุณจะขอค่าจริง ๆ งานจะเกิดขึ้นตามต้องการ ไม่ใช่ทั้งหมดในคราวเดียว 🦥
Iterable ทำงานแบบ Lazy
เมธอดอย่าง map และ where จะส่งคืน Iterable แบบ lazy จะยังไม่มีอะไรทำงานจนกว่าคุณจะวนซ้ำหรือเรียก toList
var it = [1, 2, 3].map((n) {
print('seen $n');
return n * 2;
});ยังไม่มีอะไรทำงาน
ตราบใดที่คุณยังไม่นำ iterable นั้นไปใช้ เนื้อหาของ map จะยังไม่ทำงาน ความเป็น lazy ช่วยให้คุณอธิบายงานไว้ก่อนและเลื่อน ต้นทุนออกไป
for (var x in it) print(x); // now it runsเหตุผลที่ Lazy มีประโยชน์
ความเป็น lazy ช่วยลดงานเมื่อคุณต้องการผลลัพธ์เพียงไม่กี่รายการ เมื่อใช้ร่วมกับ take คุณจะหยุดได้ตั้งแต่เนิ่น ๆ และข้ามส่วนที่เหลือ
var first2 = it.take(2).toList();ทำความรู้จักตัวสร้าง sync*
ฟังก์ชัน sync* คือตัวสร้างที่สร้าง Iterable แบบ lazy โดยจะผลิตค่าทีละค่าเมื่อมีการร้องขอ
Iterable<int> count(int n) sync* {
for (var i = 1; i <= n; i++) yield i;
}คีย์เวิร์ด yield
ภายในตัวสร้าง yield จะส่งค่าหนึ่งค่ากลับไปยังผู้เรียก แล้วหยุดรอจนกว่าจะต้องการค่าถัดไป
print(count(3).toList()); // [1, 2, 3]ลำดับที่ไม่สิ้นสุด
เนื่องจากค่าเป็นแบบ lazy ตัวสร้างจึงสามารถอธิบายลำดับที่ ไม่สิ้นสุดได้อย่างปลอดภัย ตราบใดที่คุณเลือกใช้เพียงช่วงที่มีขอบเขต
Iterable<int> naturals() sync* {
var i = 0;
while (true) yield ++i;
}เลือกช่วงที่มีขอบเขต
ใช้ตัวสร้างที่ไม่สิ้นสุดคู่กับ take เพื่อดึงมาเฉพาะสิ่งที่ต้องการ วงวนจะหยุดทันทีเมื่อได้ช่วงที่ต้องการครบ
print(naturals().take(5).toList()); // [1, 2, 3, 4, 5]yield* ส่งต่องาน
ใช้ yield* เพื่อส่งค่าทุกค่าจาก iterable หรือตัวสร้างอื่นออกมา วิธีนี้จะแผ่ลำดับหนึ่งเข้าไปในลำดับปัจจุบัน
Iterable<int> both() sync* {
yield* count(2);
yield* count(2);
}ตัวสร้างเทียบกับการสร้างรายการ
ตัวสร้างไม่จำเป็นต้องสร้างรายการทั้งหมดไว้ในหน่วยความจำ คุณสามารถส่งค่าต่อเนื่องได้ ทำให้ลำดับขนาดใหญ่หรือไม่สิ้นเปลือง หน่วยความจำเพียงเล็กน้อย
sync* เทียบกับ async*
ใช้ sync* สำหรับ iterable แบบ lazy ที่ทำงานพร้อมกัน ส่วน async* ซึ่งเป็นคู่แบบไม่พร้อมกันจะสร้าง Stream สำหรับลำดับเหตุการณ์แบบไม่พร้อมกัน
ตรวจสอบอย่างรวดเร็ว
ทดสอบความเข้าใจของคุณเกี่ยวกับตัวสร้าง
ทบทวน
Iterable ทำงานแบบ lazy และตัวสร้าง sync* จะส่งค่าตามต้องการ ทำให้คุณจำลองลำดับที่ไม่สิ้นสุดได้โดยใช้ทรัพยากรน้อย 🌟
คำถามที่พบบ่อย
บทเรียน “ตัววนซ้ำแบบขี้เกียจและตัวสร้างด้วย sync*” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “ตัววนซ้ำแบบขี้เกียจและตัวสร้างด้วย sync*” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Dart Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Dart Academy มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “ตัววนซ้ำแบบขี้เกียจและตัวสร้างด้วย sync*”
สร้างค่าตามต้องการ คุณปฏิบัติ Dart Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Dart Academy หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Dart Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน
บทเรียน “ตัววนซ้ำแบบขี้เกียจและตัวสร้างด้วย sync*” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Dart Academy นี้ได้ไหม
ได้ บทเรียน Dart Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- ฟังก์ชันลำดับสูงและการทำเคอร์รี
- fold, reduce และการขยาย
- ตัววนซ้ำแบบขี้เกียจและตัวสร้างด้วย sync*
- การประกอบสายส่งผ่านฟังก์ชันบริสุทธิ์