Jak sprawić, aby funkcja czekała na wywołanie zwrotne za pomocą node.js

Mam uproszczoną funkcję, która wygląda następująco:

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

Zasadniczo chcę, aby zadzwonił myApi.execi zwrócił odpowiedź podaną w wywołaniu zwrotnym lambda. Jednak powyższy kod nie działa i po prostu zwraca natychmiast.

Tylko dla bardzo hackerskiej próby wypróbowałem poniższe, które nie działały, ale przynajmniej masz pojęcie, co próbuję osiągnąć:

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

Zasadniczo, co jest dobrym sposobem na osiągnięcie tego? Chcę, aby moja funkcja czekała na wywołanie wywołania zwrotnego, a następnie zwraca wartość, która została do niej przekazana.

„Dobrym sterowaniem opartym na zdarzeniach node.js / event” jest nie czekać .

Podobnie jak prawie wszystko inne podczas pracy z systemami sterowanymi zdarzeniami, takimi jak węzeł, twoja funkcja powinna zaakceptować parametr wywołania zwrotnego, który zostanie wywołany po zakończeniu obliczeń. Osoba dzwoniąca nie powinna czekać na „zwrócenie” wartości w normalnym sensie, ale raczej wysłać procedurę, która będzie obsługiwała wynikową wartość:

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

Więc nie używaj go w ten sposób:

var returnValue = myFunction(query);

Ale tak:

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

Jednym ze sposobów osiągnięcia tego jest zawinięcie wywołania interfejsu API w obietnicę, a następnie użycie go w awaitcelu oczekiwania na wynik.

// 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();

Wynik:

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

sprawdź to: https://github.com/luciotato/waitfor-ES6

twój kod z wait.for: (wymaga generatorów, --harmony flag)

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

Jeśli nie chcesz korzystać z oddzwaniania, możesz użyć modułu „Q”.

Na przykład:

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. 

});

Aby uzyskać więcej informacji, patrz: https://github.com/kriskowal/q

Jeśli chcesz, aby było to bardzo proste i łatwe, bez fantazyjnych bibliotek, czekanie na wykonanie funkcji zwrotnych w węźle przed wykonaniem innego kodu wygląda następująco:

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

Uwaga: prawdopodobnie nie należy używać tej odpowiedzi w kodzie produkcyjnym. To hack i powinieneś wiedzieć o implikacjach.

Istnieje uvrun moduł (zaktualizowane do nowszych wersji Nodejs tutaj ), gdzie można wykonać jedną rundę pętli na libuv głównej pętli zdarzeń (co jest Nodejs głównym pętla).

Twój kod wyglądałby tak:

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

(Możesz użyć alternatywnie uvrun.runNoWait(). Pozwoli to uniknąć problemów z blokowaniem, ale zajmie 100% procesora.)

Zauważ, że takie podejście unieważnia cały cel Nodejsa, tj. Aby wszystko było asynchroniczne i nieblokujące. Może to również znacznie zwiększyć głębokość stosu wywołań, co może spowodować przepełnienie stosu. Jeśli uruchomisz taką funkcję rekurencyjnie, na pewno napotkasz problemy.

Zobacz inne odpowiedzi na temat przeprojektowania kodu, aby zrobić to „dobrze”.

To rozwiązanie tutaj jest prawdopodobnie przydatne tylko podczas testowania i esp. chcę mieć zsynchronizowany i seryjny kod.

Od węzła 4.8.0 możesz korzystać z funkcji ES6 zwanej generatorem. Możesz zapoznać się z tym artykułem, aby uzyskać więcej informacji. Ale w zasadzie możesz użyć generatorów i obietnic, aby wykonać tę pracę. Używam Bluebird do promisify i zarządzać generator.

Twój kod powinien być w porządku, tak jak w przykładzie poniżej.

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

zakładając, że masz funkcję:

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


};

możesz skorzystać z takich wywołań zwrotnych:

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

To przeczy celowi nieblokowania IO - blokujesz go, gdy nie wymaga blokowania :)

Powinieneś zagnieździć swoje wywołania zwrotne zamiast zmuszać node.js do czekania lub wywołać inne wywołanie zwrotne wewnątrz wywołania zwrotnego, w którym potrzebujesz wyniku r.

Możliwe, że jeśli musisz wymusić blokowanie, źle myślisz o swojej architekturze.

Korzystanie z asynchronizacji i czekania jest o wiele łatwiejsze.

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

  }

}