javascript中的異步交易

Question

首先回滾是我不關心的事情。

我想能夠鎖定一系列異步函數/承諾/任務（讓我們稱之爲「事務」）與名稱/ ID（或名稱數組），以便它們按順序發生，因此係統其他部分運行的具有相同名稱的任何其他「事務」將從啓動延遲到使用相同名稱的正在運行的事務已完成。所以它基本上是排隊的異步任務，或「交易」的序列。

這裏的情況的一些示例代碼：

function a() 
{ 
    // do stuff 
    return new Promise(/*...*/); 
} 


function b() 
{ 
    // do stuff 
    return new Promise(/*...*/); 
} 



function c() 
{ 
    // do stuff 
    return a.then(() => b()); 
} 

隨時

目前，該系統可以調用a，b，或c，當它我不想c和b運行在同時，但明顯的c取決於b。

我一直在尋找在NPM包，以幫助這一點，但我沒有發現任何東西，我不知道是否有人可以建議的東西，我可能會錯過這將有幫助呢？

Answer 1

你可以去https://github.com/Reactive-Extensions/RxJS

他們有許多函數來處理單/多/依賴/並行異步調用。

Answer 2

你可以寫你自己的小事務管理器。

const transactions = {}; 

function doTransaction(name, promiseFunc) { 
    transactions[name] = (transactions[name] || Promise.resolve()).then(promiseFunc); 
} 

Answer 3

我認爲gulp任務可以幫助你開箱。這保證了c總是b後運行等b後a

const gulp = require('gulp'); 
gulp.task('a', done => { 
    // do stuff 
    console.log('a'); 
    done(); 
}); 

gulp.task('b', ['a'], done => { 
    // do stuff 
    console.log('b'); 
    done(); 
}); 

gulp.task('c', ['b'], done => { 
    // do more stuff 
    console.log('c'); 
    done(); 
}); 

gulp.start('c'); // Logs a, b, c 

Try it!

Answer 4

function a() 
{ 
    // do stuff 
    return new Promise(/*...*/); 
} 

function b() 
{ 
    // do stuff 
    return new Promise(/*...*/); 
} 

function c() 
{ 
    // do stuff 
    return new Value; 
} 

a().then(function(data_a) { 
    // you can make use of return value (which is data_a) here or as an argument for function b or even function c 
    b().then(function(data_b) { 
    // you can make use of return value (which is data_b) here or as an argument for function c 
    c().then(function(data_c) { 
     // do your coding here 
    }); 
    }); 
}); 

您可以檢查此鏈接以供參考：https://spring.io/understanding/javascript-promises

Answer 5

使用異步/等待，並有通天transpile它。 Async Babel Docs

function a() 
{ 
    // do stuff 
    return new Promise(/*...*/); 
} 


async function b() 
{ 
    const aData = await a(); 
    // do stuff 
    return new Promise(/*...*/); 
} 



async function c() 
{ 
    const bData = await b(); 
    // do stuff 
    return bData; 
} 

Answer 6

好的，這是我的要求。 您可以使用函數b的包裝函數返回對象，並使用兩種方法：doCall和wait。包裝只能被調用一次。

doCall將調用你的函數並跟蹤其完成的wait（）的函數。

wait()將等待完成，並始終解決在doCall（）完成

現在的代碼，也CodePen（見開發者控制檯）：

function wrapPromiseFn(fn) { 
 
    var prev = null; 
 
    var doCall = function() { 
 
    var retValue; 
 

 
    prev = new Promise(function(resolve, reject) { 
 
     retValue = fn(); 
 
     retValue.then(function(result) { 
 
     resolve(true); 
 
     }); 
 
     retValue.catch(function(result) { 
 
     resolve(true); 
 
     }); 
 
    }); 
 

 
    return retValue; 
 
    }; 
 

 
    var wait = function() { 
 
    return prev ? prev : Promise.resolve(false); 
 
    }; 
 

 
    return { 
 
    doCall: doCall, 
 
    wait: wait 
 
    }; 
 
} 
 

 
function a() { 
 
    return Promise.resolve(42); 
 
} 
 

 
function b() { 
 
    //return Promise.reject(new Date()); 
 
    return Promise.resolve(new Date().getTime()); 
 
} 
 

 
var wrappedB = wrapPromiseFn(b); 
 

 
function doStuff() { 
 
    return wrappedB.wait().then(function(didWait) { 
 
    return a().then(function(_a) { 
 
     return wrappedB.doCall().then(function(_b) { 
 
     console.log("didWait, a, b: ", didWait, _a, _b); 
 
     }); 
 
    }); 
 
    }); 
 
} 
 

 
//run it twice to prove it did wait 
 
doStuff().then(doStuff)

它證明了這個概念，當然它需要一些波蘭語將參數doCall傳遞給包裝函數。