0Pricing
Swift Academy · บทเรียน

ฟังก์ชันบริสุทธิ์และการออกแบบที่ไม่มีผลข้างเคียง

เขียนฟังก์ชันที่คืนผลลัพธ์เดิมเสมอเมื่อได้รับอินพุตเดิม

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

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

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

คำจำกัดความของฟังก์ชันบริสุทธิ์

ฟังก์ชันจะบริสุทธิ์เมื่อ: • ข้อมูลเข้าเดิมให้ผลลัพธ์เดิมเสมอ • ไม่มีผลข้างเคียงที่สังเกตได้ (ไม่มีการเปลี่ยนแปลงข้อมูล การรับส่งข้อมูล หรือสถานะส่วนกลาง) ```swift func add(_ a: Int, _ b: Int) -> Int { a + b } // pure ```

ตัวอย่างฟังก์ชันที่ไม่บริสุทธิ์

```swift var total = 0 func addToTotal(_ n: Int) { total += n } // impure — mutates global ``` การเรียกใช้ฟังก์ชันนี้สองครั้งด้วย `5` อาจให้ผลลัพธ์ต่างกันหากเรียกใช้ในบริบทต่างกัน

ความโปร่งใสเชิงการอ้างอิง

สามารถแทนที่การเรียกใช้ฟังก์ชันบริสุทธิ์ด้วยผลลัพธ์ของฟังก์ชันได้โดยไม่เปลี่ยนพฤติกรรมของโปรแกรม: ```swift let result = add(2, 3) // same as writing 5 ```

ประโยชน์ของฟังก์ชันบริสุทธิ์

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

ชนิดค่าใน Swift ช่วยให้เกิดความบริสุทธิ์

เนื่องจากเมธอดของ struct ได้รับสำเนา จึงมีแนวโน้มที่จะบริสุทธิ์โดยธรรมชาติ: ```swift struct Vector { var x, y: Double } func scaled(_ v: Vector, by f: Double) -> Vector { Vector(x:v.x*f, y:v.y*f) } ```

การแยกผลข้างเคียง

นำผลข้างเคียงไปไว้ที่ขอบเขตของระบบ: ```swift // Pure core logic: func processOrders(_ orders: [Order]) -> Invoice { ... } // Impure at the edge: func run() { let inv = processOrders(load()); save(inv) } ```

ฟังก์ชันบริสุทธิ์และการทดสอบ

```swift func test() { let result = add(2, 3) assert(result == 5) // no mocks needed! } ``` ฟังก์ชันบริสุทธิ์ไม่ต้องใช้ออบเจ็กต์จำลอง — เพียงเรียกใช้และตรวจสอบผลลัพธ์

ตัวอย่างจากการใช้งานจริง

```swift func discountedPrice(base: Double, discount: Double) -> Double { base * (1 - discount) } let final = discountedPrice(base: 100, discount: 0.2) // 80.0 ```

การประกอบฟังก์ชันบริสุทธิ์

```swift func double(_ n: Int) -> Int { n * 2 } func addOne(_ n: Int) -> Int { n + 1 } let transform: (Int) -> Int = { addOne(double($0)) } print(transform(5)) // 11 ```

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

คุณสมบัติใดทำให้ฟังก์ชันสามารถทดสอบได้ง่ายโดยไม่ต้องใช้ออบเจ็กต์จำลอง

สรุปทบทวน

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

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

บทเรียน “ฟังก์ชันบริสุทธิ์และการออกแบบที่ไม่มีผลข้างเคียง” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “ฟังก์ชันบริสุทธิ์และการออกแบบที่ไม่มีผลข้างเคียง”

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

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

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

บทเรียน “ฟังก์ชันบริสุทธิ์และการออกแบบที่ไม่มีผลข้างเคียง” ใช้เวลานานแค่ไหน

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

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

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

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

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