Tạo một lời hứa (ES6) mà không bắt đầu giải quyết nó

Sử dụng các lời hứa của ES6, làm cách nào để tạo một lời hứa mà không xác định logic để giải quyết nó? Đây là một ví dụ cơ bản (một số TypeScript):

var promises = {};
function waitFor(key: string): Promise<any> {
  if (key in promises) {
    return promises[key];
  }
  var promise = new Promise(resolve => {
    // But I don't want to try resolving anything here :(
  });

  promises[key] = promise;
  return promise;
}

function resolveWith(key: string, value: any): void {
  promises[key].resolve(value); // Not valid :(
}

Nó dễ dàng thực hiện với các thư viện hứa hẹn khác. Ví dụ của JQuery:

var deferreds = {};
function waitFor(key: string): Promise<any> {
  if (key in promises) {
    return deferreds[key].promise();
  }
  var def = $.Deferred();    
  deferreds[key] = def;
  return def.promise();
}

function resolveWith(key: string, value: any): void {
  deferreds[key].resolve(value);
}

Cách duy nhất tôi có thể thấy để làm điều này là lưu trữ hàm giải quyết ở đâu đó trong trình thực thi của lời hứa nhưng điều đó có vẻ lộn xộn và tôi không chắc nó được xác định khi nào chính xác hàm này được chạy - nó luôn chạy ngay lập tức khi đang xây dựng?

Cảm ơn.

Câu hỏi hay!

Trình phân giải được chuyển đến phương thức khởi tạo Hứa cố tình chạy đồng bộ để hỗ trợ trường hợp sử dụng này:

var deferreds = [];
var p = new Promise(function(resolve, reject){
    deferreds.push({resolve: resolve, reject: reject});
});

Sau đó, tại một số thời điểm sau:

 deferreds[0].resolve("Hello"); // resolve the promise with "Hello"

Lý do mà hàm tạo lời hứa được đưa ra là:

• Thông thường (nhưng không phải luôn luôn) logic phân giải được ràng buộc với việc tạo.
• Hàm tạo hứa hẹn là ném an toàn và chuyển đổi các ngoại lệ thành từ chối.

Đôi khi nó không phù hợp và trình phân giải chạy đồng bộ. Đây là bài đọc liên quan về chủ đề này .

Tôi muốn thêm 2 xu của mình vào đây. Xem xét chính xác câu hỏi " Tạo một Hứa hẹn es6 mà không cần bắt đầu giải quyết nó ", tôi đã giải quyết nó bằng cách tạo một hàm wrapper và gọi hàm wrapper để thay thế. Mã:

Giả sử chúng ta có một hàm ftrả về Promise

/** @return Promise<any> */
function f(args) {
   return new Promise(....)
}

// calling f()
f('hello', 42).then((response) => { ... })

Bây giờ, tôi muốn chuẩn bị một cuộc gọi đến f('hello', 42)mà không thực sự giải quyết nó:

const task = () => f('hello', 42) // not calling it actually

// later
task().then((response) => { ... })

Hy vọng điều này sẽ giúp ai đó :)

Tham khảo Promise.all()như được hỏi trong phần nhận xét (và được trả lời bởi @Joe Frambach), nếu tôi muốn chuẩn bị cuộc gọi đến f1('super')& f2('rainbow'), 2 hàm trả về lời hứa

const f1 = args => new Promise( ... )
const f2 = args => new Promise( ... )

const tasks = [
  () => f1('super'),
  () => f2('rainbow')
]

// later
Promise.all(tasks.map(t => t()))
  .then(resolvedValues => { ... })

Làm thế nào về một cách tiếp cận toàn diện hơn?

Bạn có thể viết một Constructor trả về một Promise mới được trang trí bằng .resolve()và .reject()các phương thức.

Bạn có thể sẽ chọn đặt tên cho hàm tạo Deferred- một thuật ngữ có nhiều ưu tiên trong [lịch sử] các hứa hẹn javascript.

function Deferred(fn) {
    fn = fn || function(){};

    var resolve_, reject_;

    var promise = new Promise(function(resolve, reject) {
        resolve_ = resolve;
        reject_ = reject;
        fn(resolve, reject);
    });

    promise.resolve = function(val) {
        (val === undefined) ? resolve_() : resolve_(val);
        return promise;//for chainability
    }
    promise.reject = function(reason) {
        (reason === undefined) ? reject_() : reject_(reason);
        return promise;//for chainability
    }
    promise.promise = function() {
        return promise.then(); //to derive an undecorated promise (expensive but simple).
    }

    return promise;
}

Bằng cách trả về một promsie được trang trí thay vì một đối tượng đơn giản, tất cả các phương thức / thuộc tính tự nhiên của lời hứa vẫn có sẵn ngoài các trang trí.

Ngoài ra, bằng cách xử lý fn, mẫu trình tiết lộ vẫn có sẵn, nếu bạn cần / chọn sử dụng nó trong chế độ Hoãn.

BẢN GIỚI THIỆU

Bây giờ, với Deferred()tiện ích tại chỗ, mã của bạn hầu như giống với ví dụ jQuery.

var deferreds = {};
function waitFor(key: string): Promise<any> {
  if (key in promises) {
    return deferreds[key].promise();
  }
  var def = Deferred();    
  deferreds[key] = def;
  return def.promise();
}

Mọi thứ đang dần trở nên tốt hơn trong vùng đất của JavaScript, nhưng đây là một trường hợp mà mọi thứ vẫn phức tạp một cách không cần thiết. Đây là một trình trợ giúp đơn giản để hiển thị các chức năng giải quyết và từ chối:

Promise.unwrapped = () => {
  let resolve, reject, promise = new Promise((_resolve, _reject) => {
    resolve = _resolve, reject = _reject
  })
  promise.resolve = resolve, promise.reject = reject
  return promise
}

// a contrived example

let p = Promise.unwrapped()
p.then(v => alert(v))
p.resolve('test')

Rõ ràng đã từng có Promise.deferngười trợ giúp, nhưng ngay cả điều đó cũng đòi hỏi đối tượng trì hoãn phải tách biệt với chính lời hứa ...

Điều khiến loại vấn đề này trông phức tạp là bản chất thủ tục của Javascript. Để giải quyết vấn đề này, tôi đã tạo một lớp đơn giản. Đây là cách nó trông như thế nào:

class PendingPromise {

    constructor(args) {
        this.args = args;
    }

    execute() {
        return new Promise(this.args);
    }
}

Lời hứa này sẽ chỉ được thực hiện khi bạn gọi execute(). Ví dụ:

function log() {
    return new PendingPromise((res, rej) => {
        console.log("Hello, World!");
    });
}

log().execute();

CPomise cho phép bạn giải quyết các lời hứa của mình bên ngoài, nhưng đây là một phản vật chất vì nó phá vỡ mô hình đóng gói Promise. ( Bản demo trực tiếp )

import CPromise from "c-promise2";

const promise = new CPromise(() => {});

promise.then((value) => console.log(`Done: ${value}`)); //123

setTimeout(() => promise.resolve(123));