การเรียกกลับรอตัดบัญชีคืออะไร

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

ฉันพยายามที่จะเข้าใจการโทรกลับรอการตัดบัญชีแม้หลังจาก googling

ใครช่วยอธิบายง่ายๆได้ไหม ฉันเขียนโปรแกรมใน Ruby แต่รู้ C / C ++ นิดหน่อย แต่ที่สำคัญที่สุดฉันเป็นโปรแกรมเมอร์ภาษาแอสเซมบลีที่มีประสบการณ์ ดังนั้นฉันสงสัยว่ามันเป็นบิตของที่อยู่ติดต่อกลับที่ได้รับป๊อปหรือไม่ ฉันหวังว่าจะได้เรียนรู้ jquery หรือ node.js และการเรียกกลับที่เลื่อนออกไปเหล่านี้ดูเหมือนจะเป็นสิ่งสำคัญสำหรับทั้งสองคน ฉันเข้าใจหลักการทำเกลียวขั้นพื้นฐาน (แม้ว่าวัตถุ mutex ทำให้ฉันเจ็บหัว)

ตามคำขอนี่คือความคิดเห็นที่นำเสนอเป็นคำตอบ:

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

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

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

เนื้อหาส่วนใหญ่เป็น async ใน node.js แต่ในเบราว์เซอร์เช่น jQuery เนื้อหาส่วนใหญ่จะเป็นแบบซิงโครนัส (ยกเว้นเห็นได้ชัดสำหรับคำขอ AJAX) เนื่องจากฟังก์ชั่นเฟิร์สคลาสมีประโยชน์อย่างมากใน JavaScript (โดยเฉพาะอย่างยิ่งเนื่องจากการสนับสนุนการปิดที่ยอดเยี่ยม) การเรียกกลับจึงถูกใช้ทุกที่ในเบราว์เซอร์ด้วยเช่นกัน แต่พวกมันไม่ใช่ "รอการตัดบัญชี" คุณ แต่หลังจากนั้นโดยฟังก์ชั่นที่คุณโทร)

ความจริงที่ว่าระบบที่รองรับนั้นเป็นตัวผลักดันเหตุการณ์นั้นเป็นมุมฉากของการใช้การเรียกกลับที่ถูกเลื่อนออกไป; คุณสามารถจินตนาการถึง node.js (ช้ามาก) ที่เริ่มเธรดสำหรับทุกการดำเนินการและจากนั้นเรียกการเรียกกลับของคุณเมื่อเธรดเสร็จสิ้นโดยไม่ต้องใช้เหตุการณ์เลย แน่นอนว่านี่เป็นรุ่นที่น่ากลัว แต่มันแสดงให้เห็นถึงจุดของฉัน :-)

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

ตอนนี้เราสามารถดูว่า Deferred Object คืออะไร นำตัวอย่างข้อมูลด้านล่างเป็นตัวอย่าง

var deferred = $.Deferred();
var promise = deferred.promise();

สิ่งที่เรามีตอนนี้คือวัตถุรอการตัดบัญชีและวัตถุสัญญาของวัตถุรอการตัดบัญชี วัตถุรอตัดบัญชีมีทุกวิธีการเช่นเดียวกับวัตถุสัญญา แต่วัตถุสัญญาเพียง แต่มีวิธีการ.done(), .fail()และที่ใช้ในการเพิ่มการเรียกกลับไปยังวัตถุที่รอการตัดบัญชีสำหรับแต่ละที่เกี่ยวข้อง.always() eventวัตถุรอการตัดบัญชีในมืออื่น ๆ มีวิธีการอื่น ๆ อีกหลายที่สำคัญที่สุดและ.resolve() .reject()เมื่อวิธีการเหล่านี้ถูกเรียกบนวัตถุรอการตัดบัญชีการเรียกกลับทั้งหมดจะถูกเรียก .resolve()fires .done()และ.always()callbacks ขณะที่.reject()เมธอด call .fail()และ.always()callbacks

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

นี่เป็นอีกตัวอย่างหนึ่งที่ฉันใช้:

function loadImage(url) {
    var def = $.Deferred(),
        img = new Image();
    $(img).on("load error",function(e){
        if (e.type === "error") {
            def.reject(url);
        }
        else {
            def.resolve(url);
        }
    });
    img.src = url;
    // return the promise object so that callbacks can
    // be defined on the deferred object.
    return def.promise();
}
loadImage("foobar.jpg").done(function(){
    alert("The image is loaded!");
}).fail(function(){
    alert("The image failed to load!");
}).always(function(){
    alert("This is always called!");
});

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับ$.Deferred()วิธีการของ jQuery และวัตถุที่ถูกเลื่อนเวลาไปที่http://api.jquery.com/category/deferred-object/

ฉันไม่แน่ใจ แต่ฉันเชื่อว่าการโทรกลับที่ deffered หมายถึงการโทรกลับแบบอะซิงโครนัสดังนั้นคุณจะมีโชคที่ดีกว่าสำหรับ googleing

คำอธิบายที่ดีที่สุดที่ฉันพบคือที่http://www.nodebeginner.org

เฮ้อาจจะยอดเยี่ยมฟังก์ชั่น () โปรดทำสิ่งที่คุณ แต่ฉันด้าย Node.js เดียวจะไม่รอที่นี่จนกว่าคุณจะเสร็จสิ้นฉันจะยังคงรันบรรทัดของรหัสด้านล่างคุณดังนั้นคุณจะโปรด callbackFunction นี้ () ที่นี่และเรียกมันเมื่อคุณทำสิ่งที่มีราคาแพงของคุณเสร็จแล้ว? ขอบคุณ!"

ในตัวอย่างนี้อาจ ExExtensiveFunction เป็น non-blocking (หรือฟังก์ชัน async) ซึ่งหมายความว่าจะไม่ถูกเรียกใช้งานทันที แต่วางไว้ในเหตุการณ์วนรอบที่เรียกว่า เธรด node.js จะทำการประมวลผลต่อไป แต่ในบางเวลามันจะตัดสินใจดำเนินการบางอย่างจากลูปเหตุการณ์ เมื่อมันมาถึง ExExtensiveFunction มันจะเรียกมันและเมื่อ ExpensiveFunction นั้นเสร็จสิ้นการประมวลผลมันก็จะเรียกการเรียกกลับ (เลื่อนออกไป) ที่ส่งผ่านเป็นพารามิเตอร์ให้กับมัน

เป็นตัวอย่างของอาจExExtensiveFunctionคุณสามารถใช้fs.readFile

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

var regularCallback = function(evt) {
    alert("I'm a callback!")
}
var asyncCallback = function(data) {
    alert("I only run when an async operation finishes!")
}

// Bind the regular callback to a button's click event
$('#mybutton').on('click', regularCallback);

// Start an ajax request to the server. The request is asynchronous, so code
// below this line will execute immediately. The callback function
// will only be called when the request is complete.
$.get("http://google.com", asyncCallback);

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

$.when( doAjax(), doAnotherAjax() ).then( haveFunWithMoreAjax ).then( animateStuff );

'เมื่อ' ช่วยให้คุณรอฟังก์ชั่นเพื่อกลับมาขนานและthenสามารถถูกล่ามโซ่ตามลำดับ

One note: jQuery deferreds ! = Promices / Aไวยากรณ์ของพวกเขานั้นแตกต่างกันเล็กน้อย

หนึ่ง: มีบทความที่ดีในหัวข้อมีที่ IEBlogและอื่น ๆ ที่อยู่ในบล็อกสุ่มบางเป็นหนังสือและคำถาม StackOverflow นิยม