PricingLoginStart free
Swift Academy · บทเรียน

ลำดับข้อมูลแบบขี้เกียจเพื่อประสิทธิภาพ

ใช้ .lazy เพื่อเลื่อนการคำนวณออกไปและหลีกเลี่ยงการสร้างอาร์เรย์ระหว่างทาง

บทเรียน 4 จาก 412 ขั้นตอน

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

ยินดีต้อนรับ

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

ปัญหาของการประเมินผลแบบทันที

```swift let result = (1...1_000_000) .filter { $0 % 7 == 0 } // creates array of ~142857 elements .map { $0 * 2 } // creates another 142857-element array .prefix(5) // Wasteful — only 5 elements needed! ```

การเพิ่ม .lazy

```swift let result = (1...1_000_000) .lazy .filter { $0 % 7 == 0 } .map { $0 * 2 } .prefix(5) // Only computes what prefix(5) needs — no intermediate arrays! print(Array(result)) // [14,28,42,56,70] ```

ชนิดคอลเลกชันแบบเลื่อนการประมวลผล

เมื่อเรียกใช้ `.lazy` กับลำดับ Swift จะส่งคืน `LazySequence` ที่ครอบลำดับนั้นไว้: ```swift let lazyArr = [1,2,3].lazy // LazySequence<[Int]> let lazyMap = lazyArr.map { $0*2 } // LazyMapSequence ```

กรณีที่การประเมินผลแบบเลื่อนการประมวลผลเหมาะกว่า

การประเมินผลแบบเลื่อนการประมวลผลเหมาะเมื่อ: • ต้องการเพียงส่วนต้นของลำดับขนาดใหญ่ • แหล่งข้อมูลเป็นลำดับไม่สิ้นสุด (ตัวสร้างแบบกำหนดเอง) • เชื่อมการแปลงข้อมูลหลายรายการกับคอลเลกชันขนาดใหญ่

ลำดับไม่สิ้นสุด

```swift struct Fibonacci: Sequence { func makeIterator() -> some IteratorProtocol { var a = 0, b = 1 return AnyIterator { let next = a; a = b; b = next + b; return next } } } let first10 = Array(Fibonacci().prefix(10)) ```

การประเมินผลแบบเลื่อนการประมวลผลร่วมกับ first(where:)

```swift let firstEven = (1...Int.max) .lazy .first { $0 % 2 == 0 } // Returns 2 immediately — doesn't iterate the whole range ```

การบังคับให้ประเมินผล

หากต้องการประมวลผลลำดับแบบเลื่อนการประมวลผลให้เสร็จและเก็บผลลัพธ์ ให้ครอบด้วย Array: ```swift let eager = Array((1...100).lazy.filter { $0 % 3 == 0 }.map { $0*2 }) ```

แบบเลื่อนการประมวลผลไม่ได้ดีกว่าเสมอไป

สำหรับคอลเลกชันขนาดเล็ก การประเมินผลแบบเลื่อนการประมวลผลมีต้นทุนจากชนิดตัวครอบ ควรวัดประสิทธิภาพก่อนใช้ `.lazy` กับทุกกระบวนการ ใช้เมื่อคอลเลกชันมีขนาดใหญ่และต้องการหยุดการประมวลผลตั้งแต่เนิ่น ๆ

ตัวสร้างแบบเลื่อนการประมวลผลแบบกำหนดเอง

```swift func naturals() -> AnyIterator { var n = 0 return AnyIterator { n += 1; return n } } Array(naturals().prefix(5)) // [1,2,3,4,5] ```

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

คำนำหน้า `.lazy` บนกระบวนการของคอลเลกชันทำหน้าที่อะไร
ตอบคำถามในบทเรียนแบบโต้ตอบ

ทบทวน

ประเด็นสำคัญ: • `.lazy` ชะลอการคำนวณของ map/filter จนกว่าจะมีการใช้ผลลัพธ์ • หลีกเลี่ยงการจัดสรรอาร์เรย์ระหว่างทาง • มีประโยชน์กับลำดับขนาดใหญ่เมื่อจำเป็นต้องใช้เพียงส่วนต้น • ใช้ร่วมกับ `prefix`, `first(where:)` เพื่อหยุดการประมวลผลตั้งแต่เนิ่น ๆ • สร้างผลลัพธ์จริงด้วย `Array(lazySeq)` เมื่อต้องการ จบบทเรียนแล้ว!
เริ่มต้นได้ฟรี

เรียนรู้ Swift ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส
122
บทเรียน
409
เริ่มเรียนฟรีดูหลักสูตรเต็ม

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

บทเรียน “ลำดับข้อมูลแบบขี้เกียจเพื่อประสิทธิภาพ” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “ลำดับข้อมูลแบบขี้เกียจเพื่อประสิทธิภาพ”

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

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

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

บทเรียน “ลำดับข้อมูลแบบขี้เกียจเพื่อประสิทธิภาพ” ใช้เวลานานแค่ไหน

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

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

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

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

  1. ฟังก์ชันบริสุทธิ์และการออกแบบที่ไม่มีผลข้างเคียง
  2. ฟังก์ชันลำดับสูง: map, flatMap, compactMap
  3. การประกอบฟังก์ชันและสายส่งข้อมูล
  4. ลำดับข้อมูลแบบขี้เกียจเพื่อประสิทธิภาพ
← กลับไปที่ Swift Academy