การใช้งาน Loop ในภาษา Haskell แบบง่าย ๆ พร้อมตัวอย่าง CODE

ในภาษา Haskell นั้นไม่มีคำสั่ง Loop แบบดั้งเดิมเหมือนในภาษาโปรแกรมอื่น ๆ อย่างเช่น C, C++, หรือ Python แต่ Haskell ใช้แนวคิดของการเพิ่มซ้ำ (Repetition) ด้วยฟังก์ชันหรือคำสั่งฟังก์ชันที่บริสุทธิ์หลายแบบ ซึ่งอาจทำให้เกิดความสับสนในตอนแรก แต่หากเข้าใจแล้วคุณจะอัศจรรย์ใจกับความงดงามของภาษา Haskell!

ความแตกต่างของ Loop ใน Haskell

ใน Haskell การทำงานที่แทน loop มักจะใช้ฟังก์ชันที่มีนิยามเป็น recursive (การเรียกตัวเอง) หรือใช้ฟังก์ชัน higher-order เช่น `map`, `fold`, หรือ `filter` เป็นต้น

วิธีใช้ `fold` ในการทำให้เหมือน Loop

ให้เรามาดูตัวอย่างการใช้ `fold` กัน นี่คือฟังก์ชันที่เราจะใช้ในการรวมเอาค่าของ List:

 sumList :: Num a => [a] -> a
sumList xs = foldr (+) 0 xs

ในตัวอย่างนี้ ฟังก์ชัน `foldr` จะทำการรวมค่าจาก list `xs` โดยใช้ฟังก์ชันบวก `+` และเริ่มจากค่าพื้นฐาน `0`

อธิบายการทำงาน

เมื่อเราเรียก `sumList [1, 2, 3]` ผลลัพธ์จะได้เป็น `6` เนื่องจาก 1 + 2 + 3 = 6

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

ลองนึกถึงสถานการณ์ที่เราอยู่ในทีมพัฒนาที่ต้องคำนวณผลรวมของคะแนนสอบนักเรียนในห้องเรียน ความต้องการของเราคือการจัดการกับคะแนนที่ส่งเข้ามาเป็น List และคำนวณหาผลรวมให้ได้อย่างรวดเร็วและถูกต้อง

 data Student = Student { name :: String, score :: Int }

totalScore :: [Student] -> Int
totalScore students = sumList (map score students)

ในตัวอย่างนี้เราสร้างข้อมูลชนิด `Student` และใช้ฟังก์ชัน `map` เพื่อดึงคะแนนของนักเรียนจาก List แล้วนำไปใช้ใน `sumList` เพื่อคำนวณผลรวม

รับมือกับฟังก์ชัน Recursive

ในบางกรณีที่คุณอาจต้องใช้ฟังก์ชัน Recursive ที่มีลักษณะคล้ายกับ Loop เรามาดูตัวอย่างฟังก์ชันฟีโบนาชชี่:

 fibonacci :: Int -> Int
fibonacci 0 = 0
fibonacci 1 = 1
fibonacci n = fibonacci (n - 1) + fibonacci (n - 2)

ในตัวอย่างนี้ฟังก์ชัน `fibonacci` จะคำนวณเลขฟีโบนาชชี่แบบ Recursive โดยการเรียกคืนตัวเองจนกว่าจะถึงค่าพื้นฐานของ `0` และ `1`

ปัญหาใน Recursive Function

 fibonacciMemo :: Int -> Int
fibonacciMemo n = fib n where fib 0 = 0
                            fib 1 = 1
                            fib m = fib (m - 1) + fib (m - 2)
                            memo = [fib x | x <- [0..n]]

เรียนรู้การเขียนโปรแกรม Haskell ที่ EPT

การเขียนโปรแกรมในภาษา Haskell อาจฟังดูท้าทายแต่ที่ EPT (Expert-Programming-Tutor) เรามีหลักสูตรที่เหมาะกับทุกระดับ ตั้งแต่ผู้เริ่มต้นจนถึงผู้เชี่ยวชาญที่ต้องการพัฒนาทักษะของตนเอง อย่ารอช้า มาสมัครเรียนที่ EPT และเข้าร่วมสัมผัสประสบการณ์การเรียนรู้ที่น่าตื่นเต้นกับโปรแกรมการสอนที่หลากหลาย เพิ่มพูนความรู้ด้านการเขียนโปรแกรม Haskell และเพิ่มพูนทักษะที่จำเป็นในโลกยุคดิจิทัล!

สรุป

การใช้งาน Loop ในภาษา Haskell ไม่ได้ตรงไปตรงมาอย่างที่คิด แต่การเข้าใจและนำไปประยุกต์ใช้กับฟังก์ชันที่เหมาะสมอย่าง `fold`, `map`, และการทำ recursive function จะช่วยให้คุณสามารถจัดการกับข้อมูลได้อย่างมีประสิทธิภาพและสร้างสรรค์ สมมุติว่าคุณต้องการพัฒนาทักษะของคุณในด้านนี้ เริ่มต้นเรียนรู้กับ EPT วันนี้และก้าวเข้าสู่การเขียนโปรแกรมที่ทรงพลัง!

หมายเหตุ: ข้อมูลในบทความนี้อาจจะผิด โปรดตรวจสอบความถูกต้องของบทความอีกครั้งหนึ่ง บทความนี้ไม่สามารถนำไปใช้อ้างอิงใด ๆ ได้ ทาง EPT ไม่ขอยืนยันความถูกต้อง และไม่ขอรับผิดชอบต่อความเสียหายใดที่เกิดจากบทความชุดนี้ทั้งทางทรัพย์สิน ร่างกาย หรือจิตใจของผู้อ่านและผู้เกี่ยวข้อง