ข้อมูลเบื้องต้นเกี่ยวกับองค์ประกอบฟังก์ชันใน Swift

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

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

เริ่มต้นใช้งาน

มาพูดคุยกันพร้อมกับแนวคิดทางคณิตศาสตร์ ในแผนภาพด้านบน "f" และ "g" เป็นสองฟังก์ชัน เราสามารถแสดงฟังก์ชันดังต่อไปนี้:

f: A -> Bg: B -> C

หากเราจัดองค์ประกอบของฟังก์ชันทั้งสองนี้ เราก็สามารถแทนค่าดังกล่าวเป็น “g o f” (คุณสามารถพูดได้ว่า g ของ f)

(g o f): A -> C such that (g o f)(a) = g(f(a)) for all a in A

ลองสำรวจให้มากขึ้นด้วยตัวอย่างง่ายๆ:

Let f(a) = 2a + 3 & g(a) = 3a + 5, then function composition

(g o f)(a) = g(f(a)) = 3(f(a)) + 5 = 3(2a + 3) + 5 = 6a + 14

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

ข้อมูลเบื้องต้นเกี่ยวกับ Swift ในฐานะภาษาโปรแกรมที่ใช้งานได้จริง

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

การนำองค์ประกอบของฟังก์ชันไปใช้อย่างรวดเร็ว

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

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

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

มาดูกันว่าเกิดอะไรขึ้นในบล็อคโค้ดด้านบน:

1. เราได้ประกาศโอเปอเรเตอร์ infix แบบกำหนดเอง “>>>” มันออกจากการเชื่อมโยงและลำดับความสำคัญเช่นเดียวกับตัวดำเนินการ +
2. เราได้ประกาศฟังก์ชันที่มีชื่อเหมือนกับชื่อตัวดำเนินการ infix ฟังก์ชันนี้ใช้ชื่อสามัญสามชนิด T, U, V และต้องใช้การปิดสองครั้งเป็นพารามิเตอร์อินพุต
3. พารามิเตอร์ด้านซ้ายคือการปิด และจะใช้อินพุตประเภท T และส่งคืนเอาต์พุตประเภท U
4. พารามิเตอร์ที่ถูกต้องก็เป็นการปิดเช่นกัน และรับอินพุตประเภท U และส่งคืนเอาต์พุตของประเภท V
5. ตอนนี้ ฟังก์ชัน>>> ส่งกลับฟังก์ชันหรือการปิดซึ่งมีประเภท (T) → V การปิดเอาต์พุตใช้อินพุตประเภท T และส่งคืนเอาต์พุตของประเภท V นี่คือเอาต์พุตทางด้านซ้าย พารามิเตอร์คืออินพุตของพารามิเตอร์ที่ถูกต้อง

left :  (T) -> U right: (U) -> V

Output Type: (T) -> V

หากคุณเข้าใจการแสดงองค์ประกอบทางคณิตศาสตร์ของฟังก์ชัน คุณจะเห็นว่าการนำ Swift ไปใช้นั้นเหมือนกันทุกประการ

6. ในเนื้อความของฟังก์ชัน จะส่งกลับผลลัพธ์ของพารามิเตอร์ด้านขวาบนพารามิเตอร์ด้านซ้าย

ตอนนี้ถ้าเราต้องการผลลัพธ์เดียวกัน (อาร์เรย์กำลังสองของจำนวนเต็มคู่ที่ไม่ซ้ำ) เราก็สามารถทำได้ด้วยองค์ประกอบของฟังก์ชัน

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

ขอบคุณสำหรับการอ่าน!