Как заставить функцию ждать, пока не будет вызван обратный вызов, используя node.js

Question

У меня есть упрощенная функция, которая выглядит следующим образом:

function(query) {
  myApi.exec('SomeCommand', function(response) {
    return response;
  });
}

В основном я хочу, чтобы он позвонил myApi.exec и возвратил ответ, который дан в лямбда-функции обратного вызова. Однако приведенный выше код не работает и просто сразу возвращается.

Просто для очень хакерской попытки, я попробовал следующее, которое не сработало, но, по крайней мере, вы поняли, чего я пытаюсь достичь:

function(query) {
  var r;
  myApi.exec('SomeCommand', function(response) {
    r = response;
  });
  while (!r) {}
  return r;
}

В принципе, каков хороший способ управления узлом.js / event-based? Я хочу, чтобы моя функция ожидала обратного вызова, а затем возвращала значение, переданное ей.

Answer 1

"Хороший узел.js / событийный" способ сделать это - не ждать .

Как и почти все остальное при работе с управляемыми событиями системами, такими как узел, ваша функция должна принимать параметр обратного вызова, который будет вызван после завершения вычислений. Вызывающая сторона не должна ждать, пока значение будет «возвращено» в обычном смысле, а должна отправить подпрограмму, которая будет обрабатывать полученное значение:

function(query, callback) {
  myApi.exec('SomeCommand', function(response) {
    // other stuff here...
    // bla bla..
    callback(response); // this will "return" your value to the original caller
  });
}

Так что вы не используете его так:

var returnValue = myFunction(query);

Но вот так:

myFunction(query, function(returnValue) {
  // use the return value here instead of like a regular (non-evented) return value
});

Answer 2

отметьте это: https://github.com/luciotato/waitfor-ES6

ваш код с wait.for: (требуются генераторы, флаг --harmony)

function* (query) {
  var r = yield wait.for( myApi.exec, 'SomeCommand');
  return r;
}

Answer 3

Один из способов добиться этого - заключить вызов API в обещание, а затем использовать await для ожидания результата.

// let's say this is the API function with two callbacks,
// one for success and the other for error
function apiFunction(query, successCallback, errorCallback) {
    if (query == "bad query") {
        errorCallback("problem with the query");
    }
    successCallback("Your query was <" + query + ">");
}

// myFunction wraps the above API call into a Promise
// and handles the callbacks with resolve and reject
function apiFunctionWrapper(query) {
    return new Promise((resolve, reject) => {
        apiFunction(query,(successResponse) => {
            resolve(successResponse);
        }, (errorResponse) => {
            reject(errorResponse)
        });
    });
}

// now you can use await to get the result from the wrapped api function
// and you can use standard try-catch to handle the errors
async function businessLogic() {
    try {
        const result = await apiFunctionWrapper("query all users");
        console.log(result);

        // the next line will fail
        const result2 = await apiFunctionWrapper("bad query");
    } catch(error) {
        console.error("ERROR:" + error);
    }
}

// call the main function
businessLogic();

Вывод:

Your query was <query all users>
ERROR:problem with the query

Answer 4

Если вы не хотите использовать обратный вызов, вы можете использовать модуль «Q».

Например:

function getdb() {
    var deferred = Q.defer();
    MongoClient.connect(databaseUrl, function(err, db) {
        if (err) {
            console.log("Problem connecting database");
            deferred.reject(new Error(err));
        } else {
            var collection = db.collection("url");
            deferred.resolve(collection);
        }
    });
    return deferred.promise;
}


getdb().then(function(collection) {
   // This function will be called afte getdb() will be executed. 

}).fail(function(err){
    // If Error accrued. 

});

Для получения дополнительной информации см .: https://github.com/kriskowal/q

Answer 5

Если вы хотите, чтобы очень просто и легко, без каких-либо необычных библиотек, дождаться выполнения функций обратного вызова в узле, прежде чем выполнять какой-либо другой код, это выглядит так:

Answer 6

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

Существует модуль uvrun (обновлен для более новых версий Nodejs здесь ), где вы можете выполнить один цикл цикла основного события libuv (который является главным циклом Nodejs) .

Ваш код будет выглядеть так:

function(query) {
  var r;
  myApi.exec('SomeCommand', function(response) {
    r = response;
  });
  var uvrun = require("uvrun");
  while (!r)
    uvrun.runOnce();
  return r;
}

(Вы могли бы альтернативно использовать uvrun.runNoWait(). Это могло бы избежать некоторых проблем с блокировкой, но потребляет 100% CPU.)

Обратите внимание, что этот подход делает недействительным всю цель Nodejs, то есть иметь все асинхронное и неблокирующее. Кроме того, это может значительно увеличить глубину стека вызовов, что может привести к переполнению стека. Если вы запустите такую ​​функцию рекурсивно, у вас наверняка возникнут проблемы.

См. Другие ответы о том, как изменить дизайн кода, чтобы сделать его «правильным».

Это решение, вероятно, здесь полезно только при тестировании и ESP. хочу синхронизировать и серийный код.

Answer 7

Начиная с узла 4.8.0, вы можете использовать функцию ES6, называемую генератором. Вы можете следовать этой статье для более глубоких понятий. Но в основном вы можете использовать генераторы и обещания, чтобы выполнить эту работу. Я использую bluebird для обещания и управления генератором.

Ваш код должен быть в порядке, как в примере ниже.

const Promise = require('bluebird');

function* getResponse(query) {
  const r = yield new Promise(resolve => myApi.exec('SomeCommand', resolve);
  return r;
}

Promise.coroutine(getResponse)()
  .then(response => console.log(response));

Answer 8

Если у вас есть функция:

var fetchPage(page, callback) {
   ....
   request(uri, function (error, response, body) {
        ....
        if (something_good) {
          callback(true, page+1);
        } else {
          callback(false);
        }
        .....
   });


};

, вы можете использовать обратные вызовы, подобные этому:

fetchPage(1, x = function(next, page) {
if (next) {
    console.log("^^^ CALLBACK -->  fetchPage: " + page);
    fetchPage(page, x);
}
});

Answer 9

Это противоречит цели неблокирующей IO - вы блокируете ее, когда она не нуждается в блокировке :)

Вы должны вкладывать свои обратные вызовы вместо того, чтобы заставлять node.js ждать, иливызовите другой обратный вызов внутри обратного вызова, где вам нужен результат r.

Скорее всего, если вам нужно принудительно блокировать, вы думаете о своей архитектуре неправильно.