รูปแบบฟังก์ชัน

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

เชิงประกาศและเชิงกําหนด

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

นี่คือตัวอย่างนิพจน์:

SELECT * 
FROM Students s
WHERE s.Location = "Ohio" 

สิ่งที่ทําให้รหัสนี้เปิดเผยคือ คุณขอ ว่าคุณต้องการ อะไร แต่คุณไม่ได้ระบุ วิธี ที่คุณต้องการให้ปัญหาสามารถแก้ไขได้ คุณออกจาก วิธีการ ไปยัง SQL

คุณยังสามารถใช้วิธีนี้กับ F# ได้ โค้ดต่อไปนี้ใช้วิธีการที่เปิดเผย:

let studentsFromOhio = 
    allStudents  
    |> filterLocation "Ohio"

ในโค้ดก่อนหน้า คุณดําเนินการกับข้อมูลและถามสิ่งที่คุณต้องการโดยไม่ต้องเจาะจงเกี่ยวกับวิธีการที่คุณต้องการให้ดําเนินการ เมื่อโค้ดของคุณมีลักษณะเหมือนกับตัวอย่างก่อนหน้า คุณสามารถอ่านและให้เหตุผลได้อย่างง่ายดาย เมื่อต้องการเข้าถึงจุดนี้ มาดูรูปแบบที่เป็นประโยชน์บางอย่างที่สนับสนุนใน F#

รูปแบบการทํางาน

มีรูปแบบที่มีประโยชน์บางอย่างใน F# ที่คุณสามารถใช้เพื่อ วิธีการทํางานของ มากขึ้น เราจะครอบคลุมรูปแบบต่อไปนี้:

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

ส่วนประกอบ

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

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

ในตัวอย่างต่อไปนี้ ฟังก์ชัน add2() ถูกเรียก และผลลัพธ์จะถูกป้อนให้กับฟังก์ชัน multiply3()

let add2 a = a + 2
let multiply3 a = a * 3 
let addAndMultiply a =
    let sum = add2 a
    let product = multiply3 sum
    product

printfn "%i" (addAndMultiply 2) // 12

รูปแบบนี้เป็นรูปแบบทั่วไปดังนั้น F# มีตัวดําเนินการ ตัวดําเนินการ >> ช่วยให้คุณสามารถรวมฟังก์ชันสองรายการขึ้นไปเป็นฟังก์ชันที่มีขนาดใหญ่กว่าหนึ่งฟังก์ชันได้ ด้วยการใช้ตัวดําเนินการ >> คุณสามารถลดความซับซ้อนของโค้ดก่อนหน้าได้ ดังนี้:

let add2 a = a + 2
let multiply3 a = a * 3 
let addAndMultiply = add2 >> multiply3

printfn "%i" (addAndMultiply 2) // 12

ฟังก์ชันที่รวมกัน addAndMultiply() ใช้ฟังก์ชันที่ประกอบด้วยจากซ้ายไปขวา ในตัวอย่างนี้ add2() เกิดขึ้นก่อนและ multiply3() เกิดขึ้นล่าสุด

ท่อ

ตัวดําเนินการไปป์ไลน์ |> ใช้ฟังก์ชันและอาร์กิวเมนต์และส่งกลับค่า มาดูความแตกต่างของไปป์ไลน์จากองค์ประกอบด้วยตัวอย่างนี้:

let list = [4; 3; 1]
let sort (list: int list) = List.sort list
let print (list: int list)= List.iter(fun x-> printfn "item %i" x) list

list |> sort |> print // item 1 item 3 item 4

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