So lassen Sie eine Funktion mit node.js warten, bis ein Rückruf aufgerufen wurde

Ich habe eine vereinfachte Funktion, die so aussieht:

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

Grundsätzlich möchte ich, dass es aufruft myApi.execund die Antwort zurückgibt, die im Rückruf-Lambda gegeben wird. Der obige Code funktioniert jedoch nicht und kehrt einfach sofort zurück.

Nur für einen sehr hackigen Versuch habe ich das Folgende ausprobiert, was nicht funktioniert hat, aber zumindest kommt Ihnen die Idee, was ich erreichen möchte:

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

Was ist im Grunde eine gute "node.js / event-gesteuerte" Vorgehensweise? Ich möchte, dass meine Funktion wartet, bis der Rückruf aufgerufen wird, und dann den Wert zurückgibt, der an sie übergeben wurde.

Die "gute node.js / eventgesteuerte" Methode, dies zu tun, besteht darin, nicht zu warten .

Wie fast alles andere bei der Arbeit mit ereignisgesteuerten Systemen wie Node sollte Ihre Funktion einen Rückrufparameter akzeptieren, der aufgerufen wird, wenn die Berechnung abgeschlossen ist. Der Aufrufer sollte nicht warten, bis der Wert im normalen Sinne "zurückgegeben" wird, sondern die Routine senden, die den resultierenden Wert verarbeitet:

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

Also benutzt du es nicht so:

var returnValue = myFunction(query);

Aber so:

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

Eine Möglichkeit, dies zu erreichen, besteht darin, den API-Aufruf in ein Versprechen zu verpacken und dann awaitauf das Ergebnis zu warten.

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

Ausgabe:

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

Überprüfen Sie dies: https://github.com/luciotato/waitfor-ES6

Ihr Code mit wait.for: (erfordert Generatoren, --harmony Flag)

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

Wenn Sie den Rückruf nicht verwenden möchten, können Sie das Modul "Q" verwenden.

Beispielsweise:

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. 

});

Weitere Informationen finden Sie unter: https://github.com/kriskowal/q

Wenn Sie möchten, dass es sehr einfach und unkompliziert ist, warten Sie auf die Ausführung von Rückruffunktionen im Knoten, bevor Sie einen anderen Code ausführen:

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

Hinweis: Diese Antwort sollte wahrscheinlich nicht im Produktionscode verwendet werden. Es ist ein Hack und Sie sollten über die Auswirkungen Bescheid wissen.

Es ist das uvrun Modul (aktualisiert für neuere Versionen NodeJS hier ) , wo man eine einzige Schleife Runde der libuv Hauptereignisschleife ausführen kann (die die NodeJS Hauptschleife ist).

Ihr Code würde folgendermaßen aussehen:

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

(Sie könnten eine alternative Verwendung verwenden uvrun.runNoWait(). Dadurch könnten einige Probleme beim Blockieren vermieden werden, es wird jedoch 100% CPU benötigt.)

Beachten Sie, dass dieser Ansatz den gesamten Zweck von Nodejs ungültig macht, dh alles asynchron und nicht blockierend zu machen. Außerdem kann dies die Callstack-Tiefe erheblich erhöhen, sodass möglicherweise Stapelüberläufe auftreten. Wenn Sie eine solche Funktion rekursiv ausführen, werden Sie definitiv auf Probleme stoßen.

In den anderen Antworten erfahren Sie, wie Sie Ihren Code neu gestalten, um ihn "richtig" zu machen.

Diese Lösung hier ist wahrscheinlich nur nützlich, wenn Sie testen und esp. möchte synchronisierten und seriellen Code haben.

Seit Knoten 4.8.0 können Sie die als Generator bezeichnete Funktion von ES6 verwenden. Sie können diesem Artikel für tiefere Konzepte folgen . Aber im Grunde können Sie Generatoren und Versprechen verwenden, um diese Arbeit zu erledigen. Ich benutze Bluebird , um den Generator zu versprechen und zu verwalten.

Ihr Code sollte wie im folgenden Beispiel in Ordnung sein.

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

Angenommen, Sie haben eine Funktion:

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


};

Sie können Rückrufe wie folgt verwenden:

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

Das macht den Zweck des nicht blockierenden E / A zunichte - Sie blockieren es, wenn es nicht blockiert werden muss :)

Sie sollten Ihre Rückrufe verschachteln, anstatt node.js zum Warten zu zwingen, oder einen anderen Rückruf innerhalb des Rückrufs aufrufen, bei dem Sie das Ergebnis von benötigen r.

Wenn Sie das Blockieren erzwingen müssen, denken Sie wahrscheinlich an Ihre Architektur.

Mit Async und Warten ist es viel einfacher.

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

  }

}