Functional Programming คืออะไร? บทช่วยสอนพร้อมตัวอย่าง

Functional Programming คืออะไร?

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

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

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

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

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

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

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

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

ต่อไปนี้เป็นภาษาโปรแกรม Functional ที่โดดเด่นที่สุดบางส่วน:

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

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

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

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

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

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

modularity

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

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

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

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

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

การปิด

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

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

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

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

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

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

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

ตัวอย่าง:

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

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

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

ตัวอย่าง

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

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

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

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

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

ผลข้างเคียง

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

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

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

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

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

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

ฟังก์ชั่นการเขียนโปรแกรม Function	OOP
FP ใช้ข้อมูลที่ไม่เปลี่ยนรูป	OOP ใช้ข้อมูลที่ไม่แน่นอน
เป็นไปตามโมเดลการเขียนโปรแกรมแบบประกาศ	เป็นไปตามรูปแบบการเขียนโปรแกรมที่จำเป็น
สิ่งที่เน้นคือ: “คุณกำลังทำอะไรอยู่ ในโปรแกรม”	สิ่งที่มุ่งเน้นคือ "คุณเขียนโปรแกรมของคุณอย่างไร"
รองรับการเขียนโปรแกรมแบบขนาน	ไม่รองรับการเขียนโปรแกรมแบบขนาน
ฟังก์ชั่นของมันไม่มีผลข้างเคียง	วิธีการนี้อาจทำให้เกิดผลข้างเคียงได้มากมาย
Flow Control ดำเนินการโดยใช้การเรียกใช้ฟังก์ชันและการเรียกใช้ฟังก์ชันพร้อมการเรียกซ้ำ	กระบวนการควบคุมการไหลดำเนินการโดยใช้ลูปและคำสั่งแบบมีเงื่อนไข
ลำดับการดำเนินการของงบไม่สำคัญมาก	ลำดับการดำเนินการของงบเป็นสิ่งสำคัญ
รองรับทั้ง "นามธรรมเหนือข้อมูล" และ "นามธรรมเหนือพฤติกรรม"	รองรับเฉพาะ "นามธรรมเหนือข้อมูล"

สรุป

• Functional Programming หรือ FP เป็นวิธีคิดเกี่ยวกับการสร้างซอฟต์แวร์ตามหลักการกำหนดพื้นฐานบางประการ
• แนวคิดการเขียนโปรแกรมเชิงฟังก์ชันมุ่งเน้นไปที่ผลลัพธ์ ไม่ใช่กระบวนการ
• วัตถุประสงค์ของภาษา FP ใดๆ คือการเลียนแบบฟังก์ชันทางคณิตศาสตร์
• ภาษาโปรแกรมเชิงฟังก์ชันที่โดดเด่นที่สุด: 1) Haskell 2) SM 3) Clojure 4) Scala 5) Erlang 6) Clean
• 'ฟังก์ชันบริสุทธิ์' คือฟังก์ชันที่อินพุตได้รับการประกาศเป็นอินพุตและไม่ควรซ่อนฟังก์ชันใดไว้ เอาต์พุตยังถูกประกาศเป็นเอาต์พุตอีกด้วย
• ข้อมูลที่ไม่เปลี่ยนรูปหมายความว่าคุณควรจะสามารถสร้างโครงสร้างข้อมูลได้อย่างง่ายดาย แทนที่จะแก้ไขโครงสร้างข้อมูลที่มีอยู่แล้ว
• ช่วยให้คุณหลีกเลี่ยงปัญหาที่ทำให้เกิดความสับสนและข้อผิดพลาดในโค้ด
• Functional Code ไม่ใช่เรื่องง่าย ดังนั้นจึงเป็นเรื่องยากที่จะเข้าใจสำหรับผู้เริ่มต้น
• FP ใช้ข้อมูลที่ไม่เปลี่ยนรูปในขณะที่ OOP ใช้ข้อมูลที่ไม่เปลี่ยนรูป