การส่งฟังก์ชั่นไปยังฟังก์ชั่นอื่น ๆ เป็นพารามิเตอร์แนวปฏิบัติที่ไม่ดี

เราอยู่ในขั้นตอนของการเปลี่ยนแปลงวิธีที่แอปพลิเคชัน AS3 ของเราพูดถึงกับส่วนหลังของเราและเรากำลังอยู่ในขั้นตอนของการนำระบบ REST ไปใช้เพื่อแทนที่เครื่องเก่าของเรา

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

มันให้ฉันว่า "ความรู้สึกไม่ดี" ที่ฉันรู้สึกว่ามันเป็นวิธีปฏิบัติที่น่ากลัวและฉันสามารถคิดด้วยเหตุผลบางอย่างว่าทำไม แต่ฉันต้องการการยืนยันบางอย่างก่อนที่ฉันจะเสนองานระบบอีกครั้ง ฉันสงสัยว่าใครมีประสบการณ์กับปัญหานี้หรือไม่

มันไม่ใช่ปัญหา

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

ชนิดของฟังก์ชั่นนี้ยังเป็นกลุ่มอาคารพื้นฐานในการเขียนโปรแกรมการทำงานและมีการใช้อย่างกว้างขวางในภาษาทำงานเช่นHaskell

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

พวกเขาไม่เพียงใช้สำหรับการเขียนโปรแกรมการทำงาน พวกเขายังสามารถเรียกว่าการเรียกกลับ :

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

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

ฉันเขียนห้องสมุดที่ดึงข้อมูล Torrent จาก seedbox ของคุณ คุณกำลังใช้ลูปของเหตุการณ์ที่ไม่บล็อกเพื่อเรียกใช้ไลบรารีนี้และรับข้อมูลจากนั้นส่งคืนไปยังผู้ใช้ (พูดในบริบท websocket) ลองนึกภาพคุณมี 5 คนที่เชื่อมต่อกันในการวนรอบเหตุการณ์นี้และหนึ่งในคำขอเพื่อรับแผงขายข้อมูลฝนตกหนักของใครบางคน ที่จะปิดกั้นทั้งวง ดังนั้นคุณต้องคิดแบบอะซิงโครนัสและใช้การเรียกกลับ - วนซ้ำยังคงทำงานอยู่และ "ให้ข้อมูลกลับไปยังผู้ใช้" จะทำงานเฉพาะเมื่อฟังก์ชันเสร็จสิ้นการดำเนินการดังนั้นจึงไม่ต้องรอ ไฟและลืม

นี่ไม่ใช่สิ่งเลวร้าย ในความเป็นจริงมันเป็นสิ่งที่ดีมาก

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

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

ในทางเทคนิคแล้ว C ++ functor ก็เป็นประเภทของวัตถุโทรกลับซึ่งใช้ประโยชน์จากน้ำตาล syntactic operator()()เพื่อทำสิ่งเดียวกัน

ในที่สุดก็มีพอยน์เตอร์ฟังก์ชั่น C-style ที่ควรใช้ใน C เท่านั้นฉันจะไม่ลงรายละเอียดเลยฉันแค่พูดถึงมันเพื่อความสมบูรณ์ บทคัดย่ออื่น ๆ ที่กล่าวมาข้างต้นนั้นเหนือกว่าและควรใช้ในภาษาที่มีอยู่

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

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

public void doSomethingGeneric(ISpecifier specifier) {
    //do generic stuff
    specifier.doSomethingSpecific();
    //do some other generic stuff
}

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

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

มีข้อเสียเปรียบที่เป็นไปได้บางประการของการโทรกลับอย่างง่าย ๆ แม้ว่า:

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

ด้วยเว็บเซอร์ที่เรียบง่ายในแบบที่คุณใช้งานได้ดี แต่มันก็น่าอึดอัดใจถ้าคุณต้องการลำดับการโทรที่ซับซ้อนมากขึ้น มีทางเลือกบางอย่างแม้ว่า ด้วย JavaScript ตัวอย่างเช่นมีการเปลี่ยนไปใช้สัญญา ( มีอะไรดีมากเกี่ยวกับสัญญาจาวาสคริปต์ )

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