翻译工具的javascript回调

Question

I'm trying to build a translation engine using node.js. I have a Python/R background so I'm not getting the hang of these so called callbacks . . .

The input is a sentence :

 var sentence = "I want to translate this"

When I hit the "Translate" button, it should trigger the translation.

Now this is the database query, I call a node.js backend at /translate

function query(string){
   var query = 
   db.call.get(query, function(result){
       if(result.length>0){
           console.log(result[0].translation);
       } else {
           // not found in database
           console.log(string);
       }
   });
}

So then it goes like this:

var wordList = sentence.split(" ");
for(i=0; i<wordList.length; i++){
     // i call the database to return me the translation for each word
     query(wordList[i]);
}

But then, the output in the console log comes like this:

output[0]: "translate", "want", "to", "I"

How can I make it come back in order? I understand there is some async and callback stuff going on, but I do believe that the guys who coded node are smart and that there is surely a way to solve this pretty easily. Thanks

Answer 1

You need to take into account the fact that your query function might take a different time to return depending on the string argument you pass it. Right now, in your example code, if the query for "want" returns before the query for "I", then your translations will be outputted in the same order that the queries return (ie translation of "want", translation of "I").

Callbacks can help you get around this problem, because they are a function that will only get called when your query function returns. Then it's up to you to define what your program should do with the result. For instance, your program can output the results in the same order that the original array was in. This could be achieved using an index as suggested by Guffa, or using the async library that we will discuss later on.

So, one thing you could try is to pass query a callback like this:

function query(string, callback){
   db.call.get(query, function(result){
       if(result.length>0){
           callback(null, result[0].translation);
       } else {
           // not found in database
           callback(null, string);
       }
   });
}

The canonical way to use callbacks in Node.js, is to give it two parameters, so it looks like: callback(err, result) . If there is no error, you can call callback(null, result) , while when there is an error, you can call callback(err) or callback (err, result) , depending on what you want to report.

Once your query function takes a callback, you are able to know when it did return a value, and you can use the async.map function (from the async library ), like so:

var async = require('async');
var sentence = "I want to translate this";
var words = sentence.split(' ');

async.map(words, query, function (err, translations) {
   console.log(translations);
}

What this function does, is:

• run in parallel query on all the items in the words array
• wait for all the callbacks from all the query functions to return
• then call async.map 's own callback (here the third argument: function (err, translations) {console.log(translations);} )

Answer 2

The only way to make them come back in order would be to chain the calls, but then you take away the point of having asynchronous calls in the first place.

Send along the index for the word also, that way you can put the results together in the right order:

var wordList = sentence.split(" ");
var resultList = [];
var resultCount = 0;
for (i = 0; i < wordList.length; i++){
  // i call the database to return me the translation for each word
  query(wordList[i], i);
}

function query(string, index){
  var query = db.call.get(query, function(result){
    if (result.length > 0){
      resultList[index] = result[0].translation;
    } else {
      // not found in database
      resultList[index] = string;
    }
    resultCount++;
    if (resultCount == wordList.length) {
      console.log(resultList);
    }
  });
}