Làm cách nào tôi có thể thực thi mảng lời hứa theo thứ tự tuần tự?

Tôi có một loạt các lời hứa cần chạy theo thứ tự tuần tự.

var promises = [promise1, promise2, ..., promiseN];

Gọi RSVP.all sẽ thực thi chúng song song:

RSVP.all(promises).then(...); 

Nhưng, làm thế nào tôi có thể chạy chúng theo trình tự?

Tôi có thể xếp chúng theo cách thủ công như thế này

RSVP.resolve()
    .then(promise1)
    .then(promise2)
    ...
    .then(promiseN)
    .then(...);

nhưng vấn đề là số lượng lời hứa thay đổi và mảng lời hứa được xây dựng động.

Nếu bạn đã có chúng trong một mảng thì chúng đang thực thi. Nếu bạn có một lời hứa thì nó đã được thực hiện. Đây không phải là mối quan tâm của những lời hứa (IE họ không giống như C # Taskvề mặt .Start()phương pháp). .allkhông thực hiện bất cứ điều gì nó chỉ trả về một lời hứa.

Nếu bạn có một mảng các hàm trả về lời hứa:

var tasks = [fn1, fn2, fn3...];

tasks.reduce(function(cur, next) {
    return cur.then(next);
}, RSVP.resolve()).then(function() {
    //all executed
});

Hoặc các giá trị:

var idsToDelete = [1,2,3];

idsToDelete.reduce(function(cur, next) {
    return cur.then(function() {
        return http.post("/delete.php?id=" + next);
    });
}, RSVP.resolve()).then(function() {
    //all executed
});

Với các hàm không đồng bộ của ECMAScript 2017, nó sẽ được thực hiện như sau:

async function executeSequentially() {
    const tasks = [fn1, fn2, fn3]

    for (const fn of tasks) {
        await fn()
    }
}

Bạn có thể sử dụng BabelJS để sử dụng các chức năng không đồng bộ ngay bây giờ

ES7 cách năm 2017.

  <script>
  var funcs = [
    _ => new Promise(resolve => setTimeout(_ => resolve("1"), 1000)),
    _ => new Promise(resolve => setTimeout(_ => resolve("2"), 1000)),
    _ => new Promise(resolve => setTimeout(_ => resolve("3"), 1000)),
    _ => new Promise(resolve => setTimeout(_ => resolve("4"), 1000)),
    _ => new Promise(resolve => setTimeout(_ => resolve("5"), 1000)),
    _ => new Promise(resolve => setTimeout(_ => resolve("6"), 1000)),
    _ => new Promise(resolve => setTimeout(_ => resolve("7"), 1000))
  ];
  async function runPromisesInSequence(promises) {
    for (let promise of promises) {
      console.log(await promise());
    }
  }
  </script>
  <button onClick="runPromisesInSequence(funcs)">Do the thing</button>

Điều này sẽ thực thi các chức năng đã cho một cách tuần tự (từng cái một), không song song. Tham số promiseslà một mảng các hàm trả về Promise.

Ví dụ về Plunker với đoạn mã trên: http://plnkr.co/edit/UP0rhD?p=preview

Lần thử thứ hai với một câu trả lời mà tôi cố gắng giải thích rõ hơn:

Đầu tiên, một số thông tin cơ bản cần thiết, từ RSVP README :

Phần thực sự tuyệt vời đến khi bạn trả lại một lời hứa từ trình xử lý đầu tiên ... Điều này cho phép bạn làm phẳng các lệnh gọi lại lồng nhau và là tính năng chính của các lời hứa ngăn chặn "lệch phải" trong các chương trình có nhiều mã không đồng bộ.

Đây chính là cách bạn thực hiện các lời hứa một cách tuần tự, bằng cách trả lại lời hứa sau đó từ thenlời hứa sẽ kết thúc trước nó.

Sẽ rất hữu ích khi nghĩ về một tập hợp các lời hứa như một cái cây, trong đó các nhánh biểu thị các quá trình tuần tự và các lá biểu thị các quá trình đồng thời.

Quá trình xây dựng một cây hứa hẹn tương tự như nhiệm vụ rất phổ biến của việc xây dựng các loại cây khác: duy trì một con trỏ hoặc tham chiếu đến vị trí trong cây mà bạn hiện đang thêm các nhánh và lặp đi lặp lại thêm các thứ.

Như @Esailija đã chỉ ra trong câu trả lời của mình, nếu bạn có một mảng các hàm trả về lời hứa không nhận đối số, bạn có thể sử dụng reduceđể xây dựng cây một cách gọn gàng cho mình. Nếu bạn đã từng thực hiện giảm cho chính mình, bạn sẽ hiểu rằng những gì giảm đang làm đằng sau hậu trường trong câu trả lời của @ Esailija là duy trì một tham chiếu đến lời hứa hiện tại ( cur) và mỗi lời hứa trả lại lời hứa tiếp theo trong nó then.

Nếu bạn KHÔNG có một mảng thuần nhất đẹp đẽ (đối với các đối số mà chúng lấy / trả về) các hàm trả về hứa hẹn hoặc nếu bạn cần một cấu trúc phức tạp hơn một chuỗi tuyến tính đơn giản, bạn có thể tự xây dựng cây các hứa hẹn bằng cách duy trì tham chiếu đến vị trí trong cây hứa hẹn nơi bạn muốn thêm các lời hứa mới:

var root_promise = current_promise = Ember.Deferred.create(); 
// you can also just use your first real promise as the root; the advantage of  
// using an empty one is in the case where the process of BUILDING your tree of 
// promises is also asynchronous and you need to make sure it is built first 
// before starting it

current_promise = current_promise.then(function(){
  return // ...something that returns a promise...;
});

current_promise = current_promise.then(function(){
  return // ...something that returns a promise...;
});

// etc.

root_promise.resolve();

Bạn có thể xây dựng kết hợp các quy trình đồng thời và tuần tự bằng cách sử dụng RSVP.all để thêm nhiều "lá" vào một "nhánh" lời hứa. Câu trả lời không-vì-quá-phức tạp của tôi cho thấy một ví dụ về điều đó.

Bạn cũng có thể sử dụng Ember.run.scheduleOnce ('afterRender') để đảm bảo rằng điều gì đó được thực hiện trong một lời hứa sẽ được hiển thị trước khi lời hứa tiếp theo được thực hiện - câu trả lời quá phức tạp của tôi cũng cho thấy một ví dụ về điều đó.

Tuy nhiên, một cách tiếp cận khác là xác định một hàm chuỗi toàn cục trên Promisenguyên mẫu.

Promise.prototype.sequence = async (promiseFns) => {
  for (let promiseFn of promiseFns) {
    await promiseFn();
  }
}

Sau đó, bạn có thể sử dụng nó ở bất cứ đâu, giống như Promise.all()

Thí dụ

const timeout = async ms => new Promise(resolve =>
  setTimeout(() => {
    console.log("done", ms);
    resolve();
  }, ms)
);

// Executed one after the other
await Promise.sequence([() => timeout(1000), () => timeout(500)]);
// done: 1000
// done: 500

// Executed in parallel
await Promise.all([timeout(1000), timeout(500)]);
// done: 500
// done: 1000

Tuyên bố từ chối trách nhiệm: Hãy cẩn thận chỉnh sửa Nguyên mẫu!

Tất cả những gì cần thiết để giải quyết đó là một forvòng lặp :)

var promises = [a,b,c];
var chain;

for(let i in promises){
  if(chain) chain = chain.then(promises[i]);
  if(!chain) chain = promises[i]();
}

function a(){
  return new Promise((resolve)=>{
    setTimeout(function(){
      console.log('resolve A');
      resolve();
    },1000);
  });
}
function b(){
  return new Promise((resolve)=>{
    setTimeout(function(){
      console.log('resolve B');
      resolve();
    },500);
  });
}
function c(){
  return new Promise((resolve)=>{
    setTimeout(function(){
      console.log('resolve C');
      resolve();
    },100);
  });
}

Tôi đã gặp sự cố tương tự và tôi đã tạo một hàm đệ quy chạy các hàm một cách tuần tự.

var tasks = [fn1, fn2, fn3];

var executeSequentially = function(tasks) {
  if (tasks && tasks.length > 0) {
    var task = tasks.shift();

    return task().then(function() {
      return executeSequentially(tasks);
    });
  }

  return Promise.resolve();  
};

Trong trường hợp bạn cần thu thập đầu ra từ các chức năng này:

var tasks = [fn1, fn2, fn3];

var executeSequentially = function(tasks) {
  if (tasks && tasks.length > 0) {
    var task = tasks.shift();

    return task().then(function(output) {
      return executeSequentially(tasks).then(function(outputs) {
        outputs.push(output);

        return Promise.resolve(outputs);  
      });
    });
  }

  return Promise.resolve([]);
};

export type PromiseFn = () => Promise<any>;

export class PromiseSequence {
  private fns: PromiseFn[] = [];

  push(fn: PromiseFn) {
    this.fns.push(fn)
  }

  async run() {
    for (const fn of this.fns) {
      await fn();
    }
  }
}

sau đó

const seq = new PromiseSequence();
seq.push(() => Promise.resolve(1));
seq.push(() => Promise.resolve(2));
seq.run();

nó cũng có thể lưu trữ những gì hứa hẹn trả về trong một var riêng tư khác và chuyển nó cho các cuộc gọi lại

Thứ tôi theo đuổi về cơ bản là mapSeries, và tôi tình cờ lập bản đồ lưu trên một tập giá trị và tôi muốn kết quả.

Vì vậy, đây là những gì tôi có được, để giúp những người khác tìm kiếm những thứ tương tự trong tương lai ..

(Lưu ý rằng bối cảnh là một ứng dụng Ember).

App = Ember.Application.create();

App.Router.map(function () {
    // put your routes here
});

App.IndexRoute = Ember.Route.extend({
    model: function () {
            var block1 = Em.Object.create({save: function() {
                return Em.RSVP.resolve("hello");
            }});
    var block2 = Em.Object.create({save: function() {
            return Em.RSVP.resolve("this");
        }});
    var block3 = Em.Object.create({save: function() {
        return Em.RSVP.resolve("is in sequence");
    }});

    var values = [block1, block2, block3];

    // want to sequentially iterate over each, use reduce, build an array of results similarly to map...

    var x = values.reduce(function(memo, current) {
        var last;
        if(memo.length < 1) {
            last = current.save();
        } else {
            last = memo[memo.length - 1];
        }
        return memo.concat(last.then(function(results) {
            return current.save();
        }));
    }, []);

    return Ember.RSVP.all(x);
    }
});