Як змусити функцію чекати, поки виклик зворотного дзвінка за допомогою node.js

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

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

В основному, який хороший спосіб "node.js / event-driven" робити це? Я хочу, щоб моя функція зачекала, поки викликається зворотний виклик, а потім поверне значення, яке було передано йому.

Спосіб "хороший node.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
});

Один із способів цього досягти - це ввімкнути виклик 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

перевірте це: https://github.com/luciotato/waitfor-ES6

ваш код з wait.for: (потрібні генератори, --гармонійний прапор)

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

Якщо ви не хочете використовувати зворотний дзвінок, тоді ви можете скористатися модулем "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

Якщо ви хочете, щоб це було дуже просто і легко, без фантазійних бібліотек, чекати виконання функцій зворотного виклику у вузлі, перш ніж виконувати якийсь інший код, виглядає так:

//initialize a global var to control the callback state
var callbackCount = 0;
//call the function that has a callback
someObj.executeCallback(function () {
    callbackCount++;
    runOtherCode();
});
someObj2.executeCallback(function () {
    callbackCount++;
    runOtherCode();
});

//call function that has to wait
continueExec();

function continueExec() {
    //here is the trick, wait until var callbackCount is set number of callback functions
    if (callbackCount < 2) {
        setTimeout(continueExec, 1000);
        return;
    }
    //Finally, do what you need
    doSomeThing();
}

Примітка. Ця відповідь, ймовірно, не повинна використовуватися у виробничому коді. Це злом, і ви повинні знати про наслідки.

Існує модуль 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% процесора.)

Зауважте, що такий підхід зводить нанівець всю ціль Nodejs, тобто мати все асинхронізацію та не блокування. Крім того, це може значно збільшити глибину вашої ставки виклику, так що у вас може виникнути переповнення стека. Якщо ви запускаєте таку функцію рекурсивно, ви, безумовно, зіткнетеся з проблемами.

Дивіться інші відповіді про те, як переробити свій код, щоб зробити це "правильно".

Це рішення, ймовірно, корисне лише тоді, коли ви робите тестування та прослуховування. хочуть синхронізувати і серійний код.

З вузла 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));

припустимо, у вас є функція:

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

Це перешкоджає неблокуванню IO - ви блокуєте його, коли його не потрібно блокувати :)

Ви повинні вкладати зворотні дзвінки замість того, щоб примушувати node.js чекати або викликати інший зворотний дзвінок всередині зворотного дзвінка, де вам потрібен результат r.

Швидше за все, якщо вам потрібно примусити блокувати, ви думаєте про свою архітектуру неправильно.

Використовувати асинхронізацію та чекати - це набагато простіше.

router.post('/login',async (req, res, next) => {
i = await queries.checkUser(req.body);
console.log('i: '+JSON.stringify(i));
});

//User Available Check
async function checkUser(request) {
try {
    let response = await sql.query('select * from login where email = ?', 
    [request.email]);
    return response[0];

    } catch (err) {
    console.log(err);

  }

}