私は非同期メソッドを持つオブジェクトの配列を持っていると言うオブジェクト

Question

から非同期滝を作成します。

[ 
    { 
    partOne: function(input) { 
     // Do something async 
    }, 
    partTwo: function(result) { 
     // Do something w/ result of partOne 
    } 
    }, 
    { 
    partOne: function(resultOfPrevious) { 
     // Do something async 
    }, 
    partTwo: function(result) { 
     // Do something w/ result of partOne 
    } 
    }, 
    { 
    partOne: function(resultOfPrevious) { 
     // Do something async 
    }, 
    partTwo: function(result) { 
     // Do something w/ result of partOne 
    } 
    } 
] 

私は、私の入力を持つ最初のオブジェクトのpartOneを実行partTwoコールバックに結果（非同期）を渡したいです次のオブジェクトのpartOneへの入力としてpartTwoの結果を渡します。配列は、1つまたは複数のオブジェクトから構成できます。私はこの種のコードを実行するための最良のパターンが何であるか疑問に思っています。

これは、async.js：https://caolan.github.io/async/docs.html#waterfallのwaterfallメソッドと多少似ていますが、ライブラリなしでこれを行う方法とクリーナーコードを使うことができますか？

async/awaitがここで助けになるかどうかわかりませんか？元の質問は、前の関数値で何かをする次の機能を使用する場合は、単にそれから、その後に（機能を変更する滝

let collector = []; 
for (waterfallObj of waterfall) { 
    let tempArr = Object.values(waterfallObj);//get the functions out of the object 
    for (waterfallFunc of tempArr) { 
    collector.push(waterfallFunc); 
    } 
} 
//now you have your functions in order in collector 
function recursiveCallback(i) { 
    if (i>collector.length-1) { 
    return;//if there are no more to call then return 
    } 

    collector[i]().then(function(){ 
    recursiveCallback(i+1); 
    }); 
} 

と呼ばれる変数の下にある中で与えられたオブジェクトのあなたの配列を想定し

Answer 1

別のオプションをそのpassedValueを使用します。

async function processWaterfallObject (data, input) { 
    let result = input 

    for (let entry of data) { 
    result = await entry.partOne(result) 
    result = await entry.partTwo(result) 
    } 

    return result 
} 

これは、data配列内の関数がasyncであるか、Promiseを返すと仮定しています。

---

async/await現在every major browserでサポートされていると7.6.0以来nodeで利用可能です。ここで

Answer 2

（passedValueは、その後async/awaitを使用して、配列にすべてのコールバックを収集せずに、その中にrecursiveCallbackコールで

Answer 3

は、あなたが呼び出すことができるようにします内の各関数が返します値

var stack = [ 
    { 
    partOne: function(input) { 
     // Do something async 
     console.log('section one partOne', input) 
     return 'section one partOne output' 
    }, 
    partTwo: function(result) { 
     // Do something w/ result of partOne 
     console.log('section one partTwo', result) 
     return 'section one partTwo output' 
    } 
    }, 
    { 
    partOne: function(resultOfPrevious) { 
     // Do something async 
     console.log('section two partOne', resultOfPrevious) 
     return 'section two partOne output' 
    }, 
    partTwo: function(result) { 
     // Do something w/ result of partOne 
     console.log('section two partTwo', result) 
     return 'section two partTwo output' 
    } 
    }, 
    { 
    partOne: function(resultOfPrevious) { 
     // Do something async 
     console.log('section three partOne', resultOfPrevious) 
     return 'section three partOne output' 
    }, 
    partTwo: function(result) { 
     // Do something w/ result of partOne 
     console.log('section three partTwo', result) 
     return 'section three partTwo output' 
    } 
    } 
] 

を積み重ねていることを確認し、それを使用するには、スタック内の

function drain(stack, initialArg) { 
    stack.reduce(function (sectArg, section) { 
    return Object.keys(section).reduce(async function (arg, key) { 
     return await section[key].call(null,arg) 
    }, sectArg) 
    }, initialArg) 
} 

を各非同期関数を呼び出すための簡単な関数でありますスタックのように

drain(stack, 'initialArg') 

これを参照してください：https://jsfiddle.net/kqj0rror/