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

ฟังก์ชันที่รับพารามิเตอร์แบบ callback อาจถูกออกแบบมาให้เรียกตัวเองกลับไปยังผู้เรียก แต่โดยทั่วไปแล้ว ผู้ให้บริการจะเก็บการอ้างอิง callback ไว้เพื่อให้สามารถเรียกใช้ฟังก์ชันนั้นในภายหลังได้ (แบบdeferred ) หากผู้ให้บริการเรียกใช้ callback บนเธรด เดียวกัน กับผู้ใช้งาน การเรียกใช้นั้นจะเป็นแบบ blockingหรือsynchronousแต่ถ้าหากผู้ให้บริการเรียกใช้ callback บนเธรดที่แตกต่างกัน การเรียกใช้นั้นจะเป็นแบบnon -blockingหรือasynchronous

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

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

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

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

สามารถใช้ฟังก์ชันเรียกกลับ (callback) เพื่อประมวลผลแบบอะซิงโครนัสได้

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

ฟังก์ชันเรียกกลับ (callback) สามารถใช้เพื่อนำหลักการโพลีมอร์ฟิซึม มาใช้ได้ ในรหัสเทียมต่อไปนี้say_hiสามารถรับค่าได้ทั้งสอง write_statusแบบwrite_error

จากการพิมพ์นำเข้าCallabledef write_status ( message : str ) -> None : write ( stdout , message )def write_error ( message : str ) -> None : write ( stderr , message )def say_hi ( write : Callable [[ str ], None ]) -> None : write ( "Hello world" )

เทคโนโลยี Callback ถูกนำไปใช้ในรูปแบบที่แตกต่างกันไปตามภาษา โปรแกรม

ในภาษาแอสเซมบลี C, C ++ , Pascal , Modula -2และภาษาอื่นๆ ฟังก์ชันเรียกกลับจะถูกจัดเก็บไว้ภายในเป็นตัวชี้ฟังก์ชัน^{[ 1 ]}การใช้พื้นที่จัดเก็บเดียวกันทำให้ภาษาต่างๆ สามารถแชร์ฟังก์ชันเรียกกลับได้โดยตรงโดยไม่ต้องมีเลเยอร์การทำงานร่วมกันระหว่างการออกแบบหรือการทำงาน ตัวอย่างเช่นWindows APIสามารถเข้าถึงได้ผ่านหลายภาษา คอมไพเลอร์ และแอสเซมเบลอร์ C++ ยังอนุญาตให้วัตถุจัดเตรียมการใช้งานการดำเนินการเรียกฟังก์ชันไลบรารีเทมเพลตมาตรฐานยอมรับวัตถุเหล่านี้ (เรียกว่าฟังก์ชันเตอร์ ) เป็นพารามิเตอร์ภาษาไดนามิกหลายภาษาเช่นJavaScript , Lua , Python , Perl ^{[ 2 ] [ 3 ]}และPHPอนุญาตให้ส่งผ่านวัตถุฟังก์ชันภาษา CLIเช่นC#และVisual Basic (.NET) (VB.NET) ให้การอ้างอิงฟังก์ชันที่ห่อหุ้มแบบปลอดภัยประเภท ที่เรียก ว่าdelegate เหตุการณ์และตัวจัดการเหตุการณ์ตามที่ใช้ใน ภาษา .NETให้ฟังก์ชันเรียกกลับโดยทั่วไปแล้ว ภาษาโปรแกรมเชิงฟังก์ชัน จะรองรับ ฟังก์ชันระดับเฟิร์สคลาสซึ่งสามารถส่งเป็นฟังก์ชันเรียกกลับ (callback) ไปยังฟังก์ชันอื่น จัดเก็บเป็นข้อมูล หรือส่งคืนจากฟังก์ชันได้

ภาษาโปรแกรมหลายภาษา รวมถึง Perl, Python, Ruby , Smalltalk , C++ (11+), C# และ VB.NET (เวอร์ชันใหม่) และภาษาโปรแกรมเชิงฟังก์ชันส่วนใหญ่ รองรับนิพจน์แลมบ์ดาซึ่งเป็นฟังก์ชันที่ไม่มีชื่อและมีไวยากรณ์แบบอินไลน์ โดยทั่วไปจะทำหน้าที่เป็นฟังก์ชันเรียกกลับ ในบางภาษา รวมถึงScheme , ML , JavaScript, Perl, Python, Smalltalk, PHP (ตั้งแต่ 5.3.0), ^{[ 4 ]} C++ (11+), Java (ตั้งแต่ 8), ^{[ 5 ]}และภาษาอื่นๆ อีกมากมาย แลมบ์ดาสามารถเป็นโคลเชอร์ได้ กล่าวคือ สามารถเข้าถึงตัวแปรที่กำหนดไว้ในพื้นที่ในบริบทที่กำหนดแลมบ์ดา ใน ภาษา การเขียนโปรแกรมเชิงวัตถุเช่นJavaเวอร์ชันก่อนอาร์กิวเมนต์แบบฟังก์ชัน พฤติกรรมของฟังก์ชันเรียกกลับสามารถทำได้โดยการส่งวัตถุที่ใช้งานอินเทอร์เฟซ เมธอดของวัตถุนี้คือฟังก์ชันเรียกกลับ ในPL/IและALGOL 60ขั้นตอนการเรียกกลับอาจจำเป็นต้องสามารถเข้าถึงตัวแปรโลคอลในบล็อกที่บรรจุอยู่ ดังนั้นจึงมีการเรียกผ่านตัวแปรเข้าที่มีทั้งจุดเริ่มต้นและข้อมูลบริบท^{[ 6 ]}

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

#include <signal.h> #include <stdlib.h>#include <fcntl.h> #include <sys/types>struct Data { // ... };static struct Data data = { // กำหนดค่าเริ่มต้นให้กับเนื้อหาที่นี่}; static volatile sigatomic_t flag = 0 ;void cleanupHandler ( int signum ) { flag = 1 ; int saveFile = open ( "savefile.dat" , O_WRONLY | O_CREATO , S_IWUSR ); write ( saveFile , data , sizeof data ); close ( saveFile ); }int main ( void ) { signal ( cleanupHandler , SIGTERM ); doStuff (); }

การใช้งานทั่วไปอีกอย่างหนึ่งของฟังก์ชันเรียกกลับในภาษา C คือ การใช้ฟังก์ชัน ไลบรารีมาตรฐานของ Cสำหรับการเรียงลำดับ ( qsort()) และการค้นหา ( lsearch(), bsearch()) โดยที่ฟังก์ชันเปรียบเทียบจะถูกส่งผ่านเป็นอาร์กิวเมนต์ไปยังรูทีนเพื่อกำหนดลำดับการเรียง^{[ 7 ]}

#include <stdlib.h>struct Person { char name [ 20 ]; int age ; };บุคคล[ 1000 ] ;// จัดเรียงข้อมูลบุคคลตามอายุint compareAges ( struct Person * p1 , struct Person * p2 ) { return p2 -> age - p1 -> age ; }int main ( void ) { // ... int numberOfPeople = /* ตัวเลขบางอย่างตรงนี้ */ ;qsort ( numberOfPeople , sizeof ( struct Person ), people , compareAges ); // ... }

ฟังก์ชัน Callback อาจใช้เพื่อควบคุมว่าฟังก์ชันจะทำงานหรือไม่: Xlibอนุญาตให้ระบุเงื่อนไขแบบกำหนดเองเพื่อพิจารณาว่าโปรแกรมต้องการจัดการเหตุการณ์หรือไม่ ใน โค้ด C ต่อไปนี้ ฟังก์ชันprintNumber()ใช้พารามิเตอร์getNumberเป็น Callback แบบบล็อกกิ้งprintNumber()และถูกเรียกใช้ด้วยgetAnswerToMostImportantQuestion()ซึ่งทำหน้าที่เป็นฟังก์ชัน Callback เมื่อรันแล้ว ผลลัพธ์คือ: "Value: 42"

#include <stdio.h> #include <stdlib.h>void printNumber ( int ( * getNumber )( void )) { int val = getNumber (); printf ( "Value: %d \n " , val ); }int getAnswerToMostImportantQuestion ( void ) { return 42 ; }int main ( void ) { printNumber ( getAnswerToMostImportantQuestion ); return 0 ; }

ในภาษา C++ นอกจากตัวชี้ฟังก์ชันแล้ว ยังสามารถใช้ฟังก์ชันครอ นิกส์ได้อีกด้วย ฟังก์ชันครอนิกส์คืออ็อบเจ็กต์ที่มีoperator()การกำหนดคุณสมบัติไว้แล้ว ตัวอย่างเช่น อ็อบเจ็กต์ในstd::viewsคลาส `int` ก็เป็นฟังก์ชันครอนิกส์เช่นกัน นี่คือตัวอย่างการใช้ฟังก์ชันครอนิกส์ในภาษา C++:

import std ;class MyCallback { public : void operator ()( int x ) { std :: println ( "Callback called with value: {}" , x ); } };template < typename Callback > void performOperation ( int a , Callback callback ) { std :: println ( "กำลังดำเนินการกับ: {}" , a ); callback ( a ); }int main () { MyCallback callback ; int value = 10 ; performOperation ( value , callback ); return 0 ; }

std::function<R(Args...)>เป็นตัวห่อหุ้มแบบลบประเภทสำหรับอ็อบเจ็กต์ที่เรียกใช้งานได้ทุกประเภท ซึ่งถูกนำมาใช้ในC++11 :

import std ;โดยใช้std :: function ;void performOperation ( int a , function < void ( int ) > callback ) { std :: println ( "กำลังดำเนินการกับ: {}" , a ); callback ( a ); }int main () { int value = 10 ; performOperation ( value , []( int x ) -> void { std :: println ( "Callback called with value: {}" , x ); });ส่งคืนค่า0 ; }

ใน โค้ด C# ต่อไปนี้ เมธอดHelper.PerformActionใช้พารามิเตอร์callbackเป็น callback แบบบล็อกกิ้งHelper.PerformActionโดยเรียกใช้ด้วยLogซึ่งทำหน้าที่เป็นฟังก์ชัน callback เมื่อรันแล้ว จะแสดงข้อความต่อไปนี้ในคอนโซล: "Callback was: Hello world"

เนมสเปซWikipedia.Examples ;โดยใช้ระบบ;คลาสHelper { public void PerformAction ( Action < string > callback ) { callback ( "Hello world" ); } }public class Main { static void Log ( string str ) { Console . WriteLine ( $"Callback was: {str}" ); }static void Main ( string [] args ) { Helper helper = new () ; helper.PerformAction ( Log ) ; } }

ในโค้ดJavaScriptcalculate ต่อไปนี้ ฟังก์ชัน ใช้พารามิเตอร์operateเป็น callback แบบบล็อกกิ้งcalculateโดยจะถูกเรียกใช้ด้วยmultiplyและจากนั้นด้วยsumซึ่งทำหน้าที่เป็นฟังก์ชัน callback

ฟังก์ชันcalculate ( a , b , operate ) { return operate ( a , b ); } ฟังก์ชันmultiply ( a , b ) { return a * b ; } ฟังก์ชันsum ( a , b ) { return a + b ; } // แสดงผล 20 alert ( calculate ( 10 , 2 , multiply )); // แสดงผล 12 alert ( calculate ( 10 , 2 , sum ));

เมธอด `collection` .each()ของไลบรารีjQuery ใช้ฟังก์ชันที่ส่งเข้ามาเป็น callback แบบ blocking โดยจะเรียก callback นั้นสำหรับแต่ละรายการในคอลเลกชัน ตัวอย่างเช่น:

$ ( "li" ). each ( function ( index ) { console . log ( index + ": " + $ ( this ). text ()); });

^{ฟังก์ชัน}เรียกกลับแบบเลื่อนเวลามักใช้สำหรับการจัดการเหตุการณ์จากผู้ใช้ ไคลเอนต์ และตัวจับเวลา ตัวอย่างสามารถพบได้addEventListenerในAjaxและXMLHttpRequest[ ^{8 ]}

นอกเหนือจากการใช้ callback ในซอร์สโค้ด JavaScript แล้ว ฟังก์ชัน C ที่รับฟังก์ชันยังได้รับการสนับสนุนผ่าน js-ctypes อีกด้วย^{[ 9 ]}

ใน โค้ด Julia ต่อไปนี้ ฟังก์ชันcalculateจะรับพารามิเตอร์operateที่ใช้เป็น callback แบบบล็อกกิ้งcalculateโดยจะถูกเรียกใช้ด้วยsquareซึ่งทำหน้าที่เป็นฟังก์ชัน callback

julia> square ( val ) = val ^ 2 square (ฟังก์ชันทั่วไปที่มี 1 เมธอด) julia> calculate ( operate , val ) = operate ( val ) calculate (ฟังก์ชันทั่วไปที่มี 1 เมธอด) julia> calculate ( square , 5 ) 25

ในโค้ดKotlinaskAndAnswer ต่อไปนี้ ฟังก์ชัน ใช้พารามิเตอร์getAnswerเป็น callback แบบบล็อกกิ้งaskAndAnswerโดยเรียกใช้ด้วยgetAnswerToMostImportantQuestionซึ่งทำหน้าที่เป็นฟังก์ชัน callback การรันโค้ดนี้จะบอกผู้ใช้ว่าคำตอบของคำถามคือ "42"

fun main () { print ( "ป้อนคำถามที่สำคัญที่สุด: " ) val question = readLine () askAndAnswer ( question , :: getAnswerToMostImportantQuestion ) }fun getAnswerToMostImportantQuestion (): Int { return 42 }fun askAndAnswer ( question : String? , getAnswer : () -> Int ) { println ( "Question: $ question " ) println ( "Answer: ${ getAnswer () } " ) }

ในโค้ดLuacalculate นี้ ฟังก์ชัน จะรับoperationพารามิเตอร์ที่ใช้เป็น callback แบบบล็อกกิ้งcalculateโดยจะเรียกใช้ฟังก์ชันด้วยทั้งสองค่าaddและmultiplyจากนั้นจะใช้ฟังก์ชันนิรนามในการหาร

ฟังก์ชันcalculate ( a , b , operation ) ส่งคืนoperation ( a , b ) endฟังก์ชันคูณ( a , b ) ส่งคืนค่าa * bฟังก์ชันadd ( a , b ) ส่งคืนค่าa + bprint ( calculate ( 10 , 20 , multiply )) -- แสดงผล 200 print ( calculate ( 10 , 20 , add )) -- แสดงผล 30 -- ตัวอย่างการใช้ callback โดยไม่ระบุชื่อฟังก์ชันprint ( calculate ( 10 , 20 , function ( a , b ) return a / b -- แสดงผล 0.5 end ))

ใน โค้ด Python ต่อไปนี้ ฟังก์ชันcalculateจะรับพารามิเตอร์operateที่ใช้เป็น callback แบบบล็อกกิ้งcalculateโดยจะถูกเรียกใช้ด้วยsquareซึ่งทำหน้าที่เป็นฟังก์ชัน callback

def square ( val : int ) -> int : return val ** 2def calculate ( operate : Callable [[ int ], int ], val : int ) -> int : return operate ( val )# พิมพ์: 25 พิมพ์( คำนวณ( กำลังสอง, 5 ))

โค้ด RebolและRedต่อไปนี้แสดงวิธีการใช้งาน Callback

• เนื่องจาก alert ต้องการสตริง ฟอร์มจึงสร้างสตริงจากผลลัพธ์ของ calculate
• ค่า get-word! (เช่น :calc-product และ :calc-sum) จะทำให้ตัวแปลภาษาแสดงรหัสของฟังก์ชันแทนที่จะประเมินค่าด้วยฟังก์ชันนั้น
• การอ้างอิงชนิดข้อมูลในบล็อก! [float! integer!] จำกัดชนิดของค่าที่ส่งผ่านเป็นอาร์กิวเมนต์

สีแดง[ หัวข้อ: "ตัวอย่างการเรียกกลับ" ]คำนวณ: func [ num1 [ number! ] num2 [ number! ] callback-function [ function! ] ][ callback-function num1 num2 ]calc-product: func [ num1 [ number ! ] num2 [ number! ] ][ num1 * num2 ]calc-sum: func [ num1 [ number! ] num2 [ number! ] ][ num1 + num2 ]; การแจ้งเตือน 75 ผลคูณของ 5 และ 15 แบบฟอร์มการแจ้งเตือนคำนวณ5 15 :calc-product; การแจ้งเตือน 20 ผลรวมของ 5 และ 15 รูปแบบการแจ้งเตือนคำนวณ5 15 :calc-sum

RustมีFnคุณสมบัติFnMutและFnOnceลักษณะ^{[ 10 ]}

fn call_with_one < F > ( func : F ) -> usize where F : Fn ( usize ) -> usize { func ( 1 ) }let double = | x | x * 2 ; assert_eq! ( call_with_one ( double ), 2 );

• สัญชาตญาณพื้นฐาน: การใช้งานการแจ้งเตือนแบบ Callback โดยใช้ Delegates - นิตยสาร MSDN , ธันวาคม 2002
• การใช้งานฟังก์ชันเรียกกลับ (callback routines) ในภาษา Java
• การนำเฟรมเวิร์ก Script Callback มาใช้ใน ASP.NET 1.x - โครงการเขียนโค้ด, 2 สิงหาคม 2547
• การเชื่อมต่อฟังก์ชันสมาชิกของ C++ กับไลบรารีของ C (เก็บถาวรจากต้นฉบับเมื่อวันที่ 6 กรกฎาคม 2554)
• กรณีศึกษาด้านสไตล์ #2: การเรียกใช้ฟังก์ชันแบบทั่วไป