Thêm một phương pháp sau đó với một hàm để callbacks

Question

Tôi đã nhìn thấy một vài bit của mã gần đây trông giống như vậy:

myFunc(args).then(function() { ... }); 

tôi thấy cú pháp gọi lại này thực sự thanh lịch. Sự hiểu biết của tôi là đây không phải là một phần của vani vani, và tôi muốn có thể sử dụng nó vào dịp mà không phụ thuộc vào các thư viện cụ thể, vì vậy tôi quan tâm đến việc làm thế nào để thực hiện điều này bản thân mình. Vì vậy, làm thế nào loại điều này làm việc, và làm thế nào bạn sẽ thực hiện nó cho một cuộc gọi chức năng?

Answer 1

Mẫu này được gọi là "lời hứa". Nó được thực hiện bởi jQuery và dojo trong số những người khác, và một cách tiếp cận sẽ là xem mã của họ và xem cách họ thực hiện nó.

Mẫu triển khai chung là tạo một hàm trả về một đối tượng bao gồm một hàm (sau đó) để chuyển một cặp hàm như gọi lại cho phương thức trước đó, sau đó sẽ chạy hoặc thành công hoặc thất bại. MSDN có thêm về những lời hứa trong một blog post here

Có một thực hiện tối giản được đăng trên GitHub ở đây: Promises GIST

function Promise() { 
    this._thens = []; 
} 

Promise.prototype = { 

    /* This is the "front end" API. */ 

    // then(onResolve, onReject): Code waiting for this promise uses the 
    // then() method to be notified when the promise is complete. There 
    // are two completion callbacks: onReject and onResolve. A more 
    // robust promise implementation will also have an onProgress handler. 
    then: function (onResolve, onReject) { 
     // capture calls to then() 
     this._thens.push({ resolve: onResolve, reject: onReject }); 
    }, 

    // Some promise implementations also have a cancel() front end API that 
    // calls all of the onReject() callbacks (aka a "cancelable promise"). 
    // cancel: function (reason) {}, 

    /* This is the "back end" API. */ 

    // resolve(resolvedValue): The resolve() method is called when a promise 
    // is resolved (duh). The resolved value (if any) is passed by the resolver 
    // to this method. All waiting onResolve callbacks are called 
    // and any future ones are, too, each being passed the resolved value. 
    resolve: function (val) { this._complete('resolve', val); }, 

    // reject(exception): The reject() method is called when a promise cannot 
    // be resolved. Typically, you'd pass an exception as the single parameter, 
    // but any other argument, including none at all, is acceptable. 
    // All waiting and all future onReject callbacks are called when reject() 
    // is called and are passed the exception parameter. 
    reject: function (ex) { this._complete('reject', ex); }, 

    // Some promises may have a progress handler. The back end API to signal a 
    // progress "event" has a single parameter. The contents of this parameter 
    // could be just about anything and is specific to your implementation. 
    // progress: function (data) {}, 

    /* "Private" methods. */ 

    _complete: function (which, arg) { 
     // switch over to sync then() 
     this.then = which === 'resolve' ? 
      function (resolve, reject) { resolve(arg); } : 
      function (resolve, reject) { reject(arg); }; 
     // disallow multiple calls to resolve or reject 
     this.resolve = this.reject = 
      function() { throw new Error('Promise already completed.'); }; 
     // complete all waiting (async) then()s 
     var aThen, i = 0; 
     while (aThen = this._thens[i++]) { aThen[which] && aThen[which](arg); } 
     delete this._thens; 
    } 

}; 

(Lưu ý rằng đây không phải là mã của tôi Tôi nhìn qua nó và nó có vẻ tốt như là một điểm khởi đầu. , nhưng tất cả tín dụng đều chuyển đến số original author)