異步nodejs模塊導出

Question

我想知道什麼是配置模塊導出的最佳方法。下面的「async.function」的例子可以是一個或FS HTTP請求，簡化爲舉例起見：

這裏的示例代碼（asynmodule.js）：

var foo = "bar" 
async.function(function(response) { 
    foo = "foobar"; 
    // module.exports = foo; // having the export here breaks the app: foo is always undefined. 
}); 

// having the export here results in working code, but without the variable being set. 
module.exports = foo; 

如何可以導出模塊只有一次異步回調已被執行？

編輯 我的實際使用情況的快速說明：我正在寫一個模塊用來配置fs.exists nconf中（https://github.com/flatiron/nconf）（）回調（即它將解析一個配置文件，併成立nconf中）。

Answer 1

您的導出無法正常工作，因爲它在foo聲明的內部時在功能之外。但是如果你把輸出放在裏面，當你使用你的模塊時，你不能確定輸出是被定義的。

使用ansync系統的最佳方式是使用回調。您需要導出回調分配方法以獲取回調，並在異步執行時調用它。

實施例：

var foo, callback; 
async.function(function(response) { 
    foo = "foobar"; 

    if(typeof callback == 'function'){ 
     callback(foo); 
    } 
}); 

module.exports = function(cb){ 
    if(typeof foo != 'undefined'){ 
     cb(foo); // If foo is already define, I don't wait. 
    } else { 
     callback = cb; 
    } 
} 

這裏async.function只是象徵一個異步調用的佔位符。

在主

var fooMod = require('./foo.js'); 
fooMod(function(foo){ 
    //Here code using foo; 
}); 

多回調方式

如果你的模塊需要不止一次你需要管理回調的陣列更被稱爲：

var foo, callbackList = []; 
async.function(function(response) { 
    foo = "foobar"; 

    // You can use all other form of array walk. 
    for(var i = 0; i < callbackList.length; i++){ 
     callbackList[i](foo) 
    } 
}); 

module.exports = function(cb){ 
    if(typeof foo != 'undefined'){ 
     cb(foo); // If foo is already define, I don't wait. 
    } else { 
     callback.push(cb); 
    } 
} 

這裏async.function只是一個佔位符來象徵一個異步調用。

在主

var fooMod = require('./foo.js'); 
fooMod(function(foo){ 
    //Here code using foo; 
}); 

無極方式

您還可以使用無極解決。這種方法支持多個呼叫由無極設計：

var foo, callback; 
module.exports = new Promise(function(resolve, reject){ 
    async.function(function(response) { 
     foo = "foobar" 

     resolve(foo); 
    }); 
}); 

這裏async.function只是象徵一個異步調用的佔位符。

在主

var fooMod = require('./foo.js').then(function(foo){ 
    //Here code using foo; 
}); 

參見Promise documentation

Answer 2

另一種方法將被包裝的物體內部的變量。

var Wrapper = function(){ 
    this.foo = "bar"; 
    this.init(); 
}; 
Wrapper.prototype.init = function(){ 
    var wrapper = this; 
    async.function(function(response) { 
    wrapper.foo = "foobar"; 
    }); 
} 
module.exports = new Wrapper(); 

如果初始化程序有錯誤，至少仍然會得到未初始化的值而不是掛起回調。

Answer 3

您還可以使用承諾的：

一些-異步module.js

module.exports = new Promise((resolve, reject) => { 
    setTimeout(resolve.bind(null, 'someValueToBeReturned'), 2000); 
}); 

main.js

var asyncModule = require('./some-async-module'); 

asyncModule.then(promisedResult => console.log(promisedResult)); 
// outputs 'someValueToBeReturned' after 2 seconds 

---

同樣可以發生在不同的模塊中L同時，解決預期：

在幾家，其他-module.js

var asyncModule = require('./some-async-module'); 

asyncModule.then(promisedResult => console.log(promisedResult)); 
// also outputs 'someValueToBeReturned' after 2 seconds 

---

注意，承諾對象被創建一次，然後它是由節點緩存。每個require('./some-async-module')將返回相同的對象實例（在這種情況下爲promise實例）。

Answer 4

其他答案似乎是部分答案，並沒有爲我工作。這似乎是有點完整：

一些-module.js

var Wrapper = function(){ 
    this.callbacks = []; 
    this.foo = null; 
    this.init(); 
}; 
Wrapper.prototype.init = function(){ 
    var wrapper = this; 
    async.function(function(response) { 
    wrapper.foo = "foobar"; 
    this.callbacks.forEach(function(callback){ 
     callback(null, wrapper.foo); 
    }); 
    }); 
} 
Wrapper.prototype.get = function(cb) { 
    if(typeof cb !== 'function') { 
     return this.connection; // this could be null so probably just throw 
    } 
    if(this.foo) { 
     return cb(null, this.foo); 
    } 
    this.callbacks.push(cb); 
} 
module.exports = new Wrapper(); 

main.js

var wrapper = require('./some-module'); 

wrapper.get(function(foo){ 
    // foo will always be defined 
}); 

main2.js

var wrapper = require('./some-module'); 

wrapper.get(function(foo){ 
    // foo will always be defined in another script 
}); 

Answer 5

ES6使用答案承諾：

const asyncFunc =() => { 
    return new Promise((resolve, reject) => { 
     // Where someAsyncFunction takes a callback, i.e. api call 
     someAsyncFunction(data => { 
      resolve(data) 
     }) 
    }) 
} 

export default asyncFunc 

... 
import asyncFunc from './asyncFunc' 
asyncFunc().then(data => { console.log(data) }) 

或者你可以返回無極本身直接：

const p = new Promise(...) 
export default p 
... 
import p from './asyncModule' 
p.then(...) 

Answer 6

的ES7的做法將是一個立刻調用異步功能在module.exports：

module.exports = (async function(){ 
//some async initiallizers 
//e.g. await the db module that has the same structure like this 
    var db = await require("./db"); 
    var foo = "bar"; 

    //resolve the export promise 
    return { 
    foo 
    }; 
})() 

這可能需要等待以後：

(async function(){ 

    var foo = await require("./theuppercode"); 
    console.log(foo); 
})();