Come far attendere una funzione fino a quando non viene chiamato un callback usando node.js

Ho una funzione semplificata che assomiglia a questa:

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

Fondamentalmente voglio che chiami myApi.exece restituisca la risposta che è data nel callback lambda. Tuttavia, il codice sopra non funziona e restituisce semplicemente immediatamente.

Solo per un tentativo molto hacker, ho provato il seguito che non ha funzionato, ma almeno hai l'idea di cosa sto cercando di ottenere:

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

Fondamentalmente, qual è un buon modo 'node.js / event driven' per farlo? Voglio che la mia funzione attenda fino a quando non viene chiamato il callback, quindi restituisce il valore che gli è stato passato.

Il modo "good node.js / event driven" per farlo è di non aspettare .

Come quasi tutto il resto quando si lavora con sistemi basati su eventi come il nodo, la funzione deve accettare un parametro di callback che verrà richiamato quando il calcolo è completo. Il chiamante non dovrebbe attendere che il valore venga "restituito" in senso normale, ma piuttosto inviare la routine che gestirà il valore risultante:

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

Quindi non lo usi in questo modo:

var returnValue = myFunction(query);

Ma così:

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

Un modo per raggiungere questo obiettivo è avvolgere la chiamata API in una promessa e quindi utilizzare awaitper attendere il risultato.

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

Produzione:

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

controlla questo: https://github.com/luciotato/waitfor-ES6

il tuo codice con wait.for: (richiede generatori, --harmony flag)

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

Se non si desidera utilizzare la richiamata, è possibile utilizzare il modulo "Q".

Per esempio:

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. 

});

Per ulteriori informazioni, consultare: https://github.com/kriskowal/q

Se vuoi che sia molto semplice e facile, niente librerie fantasiose, attendere che le funzioni di callback vengano eseguite nel nodo, prima di eseguire qualche altro codice, è così:

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

Nota: questa risposta probabilmente non dovrebbe essere utilizzata nel codice di produzione. È un trucco e dovresti conoscere le implicazioni.

C'è l'uvrun modulo (aggiornato per le versioni più recenti Nodejs qui ), dove è possibile eseguire un singolo round ciclo della libuv ciclo evento principale (che è la Nodejs loop principale).

Il tuo codice sarebbe simile al seguente:

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

(Potrebbe essere un uso alternativo uvrun.runNoWait(). Ciò potrebbe evitare alcuni problemi con il blocco, ma richiede il 100% di CPU.)

Si noti che questo tipo di approccio invalida l'intero scopo di Nodejs, ovvero avere tutto asincrono e non bloccante. Inoltre, potrebbe aumentare molto la profondità del tuo callstack, quindi potresti finire con overflow dello stack. Se si esegue tale funzione in modo ricorsivo, si verificheranno sicuramente problemi.

Vedi le altre risposte su come riprogettare il codice per farlo "giusto".

Questa soluzione qui è probabilmente utile solo quando si eseguono test ed esp. desidera avere un codice seriale e sincronizzato.

Dal nodo 4.8.0 è possibile utilizzare la funzione di ES6 chiamata generatore. Puoi seguire questo articolo per concetti più profondi. Ma fondamentalmente puoi usare generatori e promesse per fare questo lavoro. Sto usando bluebird per promuovere e gestire il generatore.

Il tuo codice dovrebbe andare bene come nell'esempio seguente.

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

supponendo che tu abbia una funzione:

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


};

puoi utilizzare callback come questo:

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

Ciò vanifica lo scopo dell'IO non bloccante: lo stai bloccando quando non ha bisogno di essere bloccato :)

È necessario nidificare i callback invece di forzare node.js ad attendere oppure chiamare un altro callback all'interno del callback da cui è necessario il risultato r.

È probabile che, se devi forzare il blocco, stai pensando alla tua architettura in modo sbagliato.

L'uso di asincrono e l'attesa è molto più semplice.

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

  }

}