Functional Programming คืออะไร?

Functional Programming คืออะไร?

การเขียนโปรแกรมเชิงฟังก์ชัน (Functional Programming หรือ FP) คือแนวคิดเกี่ยวกับการสร้างซอฟต์แวร์โดยการสร้างฟังก์ชันบริสุทธิ์ ซึ่งหลีกเลี่ยงแนวคิดเรื่องสถานะที่ใช้ร่วมกันและข้อมูลที่เปลี่ยนแปลงได้ ซึ่งพบได้ในการเขียนโปรแกรมเชิงวัตถุ (Object Oriented Programming)

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

ลักษณะของการเขียนโปรแกรมเชิงฟังก์ชัน

• วิธีการเขียนโปรแกรมเชิงฟังก์ชันมุ่งเน้นที่ผลลัพธ์ ไม่ใช่กระบวนการ
• เน้นที่สิ่งที่จะต้องคำนวณเป็นหลัก
• ข้อมูลไม่สามารถเปลี่ยนแปลงได้
• การเขียนโปรแกรมเชิงฟังก์ชันจะแบ่งปัญหาออกเป็นฟังก์ชันต่างๆ
• มันถูกสร้างขึ้นบนแนวคิดของฟังก์ชันทางคณิตศาสตร์ ซึ่งใช้การแสดงออกตามเงื่อนไขและการเรียกซ้ำเพื่อทำการคำนวณ
• มันไม่รองรับการวนซ้ำ เช่น คำสั่งลูป และคำสั่งเงื่อนไข เช่น If-Else

ประวัติความเป็นมาของการเขียนโปรแกรมเชิงฟังก์ชัน

• พื้นฐานของการเขียนโปรแกรมเชิงฟังก์ชันคือ แคลคูลัสแลมบ์ดา ซึ่งได้รับการพัฒนาขึ้นในทศวรรษ 1930 เพื่อใช้ในการประยุกต์ใช้ การนิยาม และการเรียกซ้ำเชิงฟังก์ชัน
• LISP เป็นภาษาการเขียนโปรแกรมเชิงฟังก์ชันภาษาแรก แมคคาร์ธีออกแบบมันในปี 1960
• ในช่วงปลายทศวรรษ 70 นักวิจัยที่มหาวิทยาลัยเอดินบะระได้กำหนดนิยามของ ML (Meta Language)
• ในช่วงต้นทศวรรษ 80 ภาษาโปรแกรม Hope ได้เพิ่มชนิดข้อมูลเชิงพีชคณิตสำหรับการเรียกซ้ำและการให้เหตุผลเชิงสมการ
• ภาษาโปรแกรมเชิงฟังก์ชัน 'Scala' ได้ถูกคิดค้นขึ้นในปี 2004

ภาษาโปรแกรมเชิงฟังก์ชัน

เป้าหมายของภาษาโปรแกรมเชิงฟังก์ชันใดๆ ก็คือการเลียนแบบฟังก์ชันทางคณิตศาสตร์ อย่างไรก็ตาม กระบวนการคำนวณพื้นฐานในโปรแกรมเชิงฟังก์ชันนั้นแตกต่างออกไป

ต่อไปนี้คือภาษาการเขียนโปรแกรมเชิงฟังก์ชันที่โดดเด่นที่สุดบางส่วน:

• Haskell
• SML
• Clojure
• สกาล่า
• แอร์ลัง
• ทำความสะอาด
• F#
• ML/OCaml กระเพื่อม / โครงการ
• XSLT
• SQL
• มาติกา

คำศัพท์การเขียนโปรแกรมฟังก์ชั่นพื้นฐานและ Concepts

ข้อมูลที่ไม่เปลี่ยนรูป

ข้อมูลที่ไม่สามารถเปลี่ยนแปลงได้ หมายความว่าคุณควรจะสามารถสร้างโครงสร้างข้อมูลได้ง่ายดาย แทนที่จะแก้ไขโครงสร้างข้อมูลที่มีอยู่แล้ว

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

โปรแกรมเชิงฟังก์ชันควรดำเนินการต่างๆ ราวกับว่าเป็นการดำเนินการครั้งแรก ดังนั้นคุณจะรู้ว่าอะไรอาจเกิดขึ้นหรือไม่เกิดขึ้นระหว่างการทำงานของโปรแกรม และผลข้างเคียงที่เกิดขึ้น ในแง่ของโปรแกรมเชิงฟังก์ชัน สิ่งนี้เรียกว่า ความโปร่งใสเชิงอ้างอิง (Referential transparency)

modularity

การออกแบบแบบโมดูลาร์ช่วยเพิ่มประสิทธิภาพการทำงาน โมดูลขนาดเล็กสามารถเขียนโค้ดได้อย่างรวดเร็วและมีโอกาสนำกลับมาใช้ใหม่ได้มากขึ้น ซึ่งแน่นอนว่าจะนำไปสู่การพัฒนาโปรแกรมที่รวดเร็วยิ่งขึ้น นอกจากนี้ โมดูลยังสามารถทดสอบแยกกันได้ ซึ่งช่วยลดเวลาที่ใช้ในการทดสอบหน่วยและการแก้ไขข้อผิดพลาด

การบำรุงรักษา

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

ฟังก์ชั่นชั้นหนึ่ง

'ฟังก์ชันระดับเฟิร์สคลาส' เป็นคำจำกัดความที่ใช้กับส่วนประกอบของภาษาโปรแกรมที่ไม่มีข้อจำกัดในการใช้งาน ดังนั้น ฟังก์ชันระดับเฟิร์สคลาสจึงสามารถปรากฏที่ใดก็ได้ในโปรแกรม

การปิด

Closure คือฟังก์ชันภายในที่สามารถเข้าถึงตัวแปรของฟังก์ชันแม่ได้ แม้หลังจากที่ฟังก์ชันแม่ทำงานเสร็จสิ้นแล้วก็ตาม

ฟังก์ชั่นการสั่งซื้อที่สูงขึ้น

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

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

ฟังก์ชั่นเพียว

'ฟังก์ชันบริสุทธิ์' คือฟังก์ชันที่อินพุตได้รับการประกาศเป็นอินพุตและไม่ควรซ่อนฟังก์ชันใดไว้ เอาต์พุตยังถูกประกาศเป็นเอาต์พุตอีกด้วย

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

ตัวอย่าง:

Function Pure(a,b)
{
	return a+b;
}

ฟังก์ชันที่ไม่บริสุทธิ์

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

ตัวอย่าง

int z;
function notPure(){
	z = z+10;
}

องค์ประกอบฟังก์ชัน

องค์ประกอบของฟังก์ชันคือการรวมฟังก์ชันตั้งแต่ 2 ฟังก์ชันขึ้นไปเข้าด้วยกันเพื่อสร้างฟังก์ชันใหม่

รัฐที่ใช้ร่วมกัน

สถานะร่วม (Shared state) เป็นแนวคิดสำคัญในการเขียนโปรแกรมเชิงวัตถุ (OOP) โดยพื้นฐานแล้วมันคือการเพิ่มคุณสมบัติให้กับวัตถุ ตัวอย่างเช่น ถ้าฮาร์ดดิสก์เป็นวัตถุ เราสามารถเพิ่มความจุในการจัดเก็บและขนาดของดิสก์เป็นคุณสมบัติได้

ผลข้างเคียง

ผลข้างเคียงคือการเปลี่ยนแปลงสถานะใดๆ ที่เกิดขึ้นนอกเหนือจากฟังก์ชันที่ถูกเรียกใช้ เป้าหมายสำคัญที่สุดของภาษาการเขียนโปรแกรมเชิงฟังก์ชันใดๆ ก็คือการลดผลข้างเคียงให้น้อยที่สุดโดยการแยกผลข้างเคียงออกจากส่วนอื่นๆ ของโค้ดซอฟต์แวร์ ในการเขียนโปรแกรมเชิงฟังก์ชัน การแยกผลข้างเคียงออกจากตรรกะการเขียนโปรแกรมส่วนอื่นๆ นั้นมีความสำคัญอย่างยิ่ง

ประโยชน์ของการเขียนโปรแกรมเชิงฟังก์ชัน

• ช่วยให้คุณหลีกเลี่ยงปัญหาและความผิดพลาดที่ทำให้เกิดความสับสนในโค้ดได้
• ทดสอบและดำเนินการทดสอบหน่วย (Unit testing) และแก้ไขข้อบกพร่อง (debug) FP ได้ง่ายกว่า Code.
• การประมวลผลแบบขนานและการทำงานพร้อมกัน
• การปรับใช้โค้ดแบบ Hot Code และการทนต่อข้อผิดพลาด
• ช่วยลดความซับซ้อนของโค้ดและทำให้โค้ดสั้นลง
• เพิ่มประสิทธิภาพการทำงานของนักพัฒนาซอฟต์แวร์
• รองรับฟังก์ชันซ้อนกัน
• โครงสร้างการทำงาน เช่น Lazy Map & Lists เป็นต้น
• ช่วยให้สามารถใช้แคลคูลัสแลมบ์ดาได้อย่างมีประสิทธิภาพ

ข้อจำกัดของการเขียนโปรแกรมเชิงฟังก์ชัน

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

การเขียนโปรแกรมเชิงฟังก์ชันกับการเขียนโปรแกรมเชิงวัตถุ

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