JavaScript reduzieren mit Promises, die nicht sequenziell zurückkehren

Question

Aus irgendeinem Grund kehren alle Funktionen zur gleichen Zeit zurück.

Ich möchte warten, bis die erste Funktion auflöst, dann _done() anrufen, bevor ich die zweite Funktion anrufe, und dann _done() anrufen, dann die dritte Funktion anrufen und dann _done() erneut aufrufen.

Jedes Mal, wenn _done() aufgerufen wird, möchte ich die Werte übergeben, die aus dem vorherigen Funktionsaufruf gelöst wurden.

Die Arbeits Demo ist hier https://repl.it/MeHl/9

"use-strict" 

function _test(actions){ 
    return actions.reduce((chain, action) => { 
     const func = this[action.functionToCall](action.argumentToSend); 
     return chain.then(() => func()).then(val => console.log(val)); 
    }, Promise.resolve().then(val => _done())); 
} 

function _one(data){ 
    return new Promise((resolve, reject) => { 
     setTimeout(function(){ 
     console.log(data); 
     resolve(); 
     }, 2000); 
    }) 
} 

function _two(data){ 
    return new Promise((resolve, reject) => { 
     setTimeout(function(){ 
      console.log(data); 
      resolve(); 
     }, 2000); 
    }) 
} 

function _three(data){ 
    return new Promise((resolve, reject) => { 
     setTimeout(function(){ 
      console.log(data); 
      resolve(); 
     }, 2000); 
    }) 
} 

function _done(data){ 
    console.log(data); 
} 

const arrayOfObjects = [ 
    { functionToCall: '_one', argumentToSend: 'Yay function one was called with this argument' }, 
    { functionToCall: '_two', argumentToSend: 'Yay function two was called with this argument' }, 
    { functionToCall: '_three', argumentToSend: 'Yay function three was called with this argument' }, 
    ]; 

_test(arrayOfObjects); 

So das Protokoll wie

Yay function one was called with this argument 
resolvedFromOne 
Yay function two was called with this argument 
resolvedFromTwo 
Yay function three was called with this argument 
resolvedFromThree 

Answer 1

produziert Dieser Code aussehen sollte die erwartete Ausgabe

function _test(actions){ 
 
     return actions.reduce((chain, action) => { 
 
      return chain.then(() => action.functionToCall(action.argumentToSend)).then(val => console.log(val)); 
 
     }, Promise.resolve()); 
 
    } 
 
    
 
    function _one(data){ 
 
     return new Promise((resolve, reject) => { 
 
      setTimeout(function(){ 
 
      console.log(data); 
 
      resolve('resolvedFromOne'); 
 
      }, 2000); 
 
     }) 
 
    } 
 
    
 
    function _two(data){ 
 
     return new Promise((resolve, reject) => { 
 
      setTimeout(function(){ 
 
       console.log(data); 
 
       resolve('resolvedFromTwo'); 
 
      }, 2000); 
 
     }) 
 
    } 
 
    
 
    function _three(data){ 
 
     return new Promise((resolve, reject) => { 
 
      setTimeout(function(){ 
 
       console.log(data); 
 
       resolve('resolvedFromThree'); 
 
      }, 2000); 
 
     }) 
 
    } 
 
    
 
    // not required 
 
    function _done(data){ 
 
     console.log(data); 
 
    } 
 
    
 
    const arrayOfObjects = [ 
 
     { functionToCall: _one, argumentToSend: 'Yay function one was called with this argument' }, 
 
     { functionToCall: _two, argumentToSend: 'Yay function two was called with this argument' }, 
 
     { functionToCall: _three, argumentToSend: 'Yay function three was called with this argument' }, 
 
     ]; 
 
    
 
    _test(arrayOfObjects);