Ответ 1

Ваш экспорт не может работать, потому что он находится вне функции, а объявление foo находится внутри. Но если вы поместите экспорт внутрь, когда вы используете свой модуль, вы не можете быть уверены, что экспорт был определен.

Лучший способ работы с системой ansync - использовать обратный вызов. Вам нужно экспортировать метод назначения обратного вызова для получения обратного вызова и вызвать его при выполнении async.

Пример:

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;
});

Способ обещания

Вы также можете использовать Promise для решения этой проблемы. Этот метод поддерживает множественный вызов по дизайну обещания:

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;
});

См. Документация обещания

Ответ 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();

Если инициализатор имеет ошибку, по крайней мере вы по-прежнему получаете неинициализированное значение вместо зависания обратного вызова.

Ответ 3

Вы также можете использовать Promises:

некоторые Асинхр-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

То же самое может произойти в другом модуле и также будет разрешаться, как ожидалось:

в-некоторых-другой-module.js

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

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

Обратите внимание, что объект обещания создается один раз, затем он кэшируется node. Каждый require('./some-async-module') будет возвращать один и тот же экземпляр объекта (в этом случае экземпляр перспективы).

Ответ 4

Ответ ES6 с использованием promises:

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) })

Или вы можете напрямую вернуть сам Promise:

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

Ответ 5

Подходом ES7 была бы незамеченная функция async в 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);
})();

Ответ 6

Другие ответы, казалось, были частичными ответами и не работали для меня. Это кажется несколько полным:

некоторые-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
});