函数完成后运行代码并获得返回值

Question

Imagine i have a simple javascript function:

  function someFunction(integer)
  {
    data = integer + 1;
    return data;
  }

I need to call this from inside another function and use the returned value:

  function anotherFunction(integer)
  {
    int_plus_one = someFunction(integer);
    //Do something with the returned data...
    int_plus_two = int_plus_one + 1;
    return int_plus_two;
  }

How can i ensure that the return of anotherFunction return is only returned after someFunction completes? It actually seems to work ok with very fast functions like these. However if someFunction has to do some ajax lookups, the return of aotherFunction fails.

Thanks, Steve

Answer 1

You do not know when or even if an asynchronous function will complete. The only way to handle this is to use a callback function, a function that gets executed after the async operation has completed.

This was my "aha!" moment: How to return the response from an asynchronous call?

Answer 2

As far as your code is sync, the approach above is fine.

Once you start introducing async parts, the one below involving callbacks is a common used approach:

function fn (v, cb) {
    doSomethingAsyncWithV(function (err, _v) {
        if(err) return cb(err);
        cb(null, _v);
    })
}

function yourFirstFn () {
    var v = 0;
    fn(v, function (err, _v) {
        // do here whatever you want with the asynchronously computed value
    });
}

Answer 3

How about promise? With that in mind, there's no need to worry about callback. It's one of the cool things in AngularJS.

var q = require('q');

var myPromise =function() {
    var deferred = q.defer();
    setTimeout(function(){  
        var output = anotherFunction(1);
        deferred.resolve(output)
    }, 10000);  // take times to compute!!! 
    return deferred.promise;
}

var objPromise = myPromise();
objPromise.then(function(outputVal){
    console.log(outputVal) ; // your output value from anotherFunction
}).catch(function(reason) {
    console.log('Error: ' + reason);
})

then is ONLY exeucted after promise has been resolved. If an exception or error is caught, the catch function executes.

Answer 4

how about this?

---

   function someFunction(integer, callback)
   {
       data = integer + 1;
       return callback(data);
   }



  function anotherFunction(integer)
  {
     int_plus_one = someFunction(integer, function(data){
         int_plus_two = int_plus_one + 1;
         return int_plus_two;
     });
    //Do something with the returned data...

  }

Answer 5

You could use promises:

new Promise(function someFunction(resolve, reject) {
    ajaxLib.get(url, options, function (data) {
        resolve(data);
    });
}).then(function anotherFunction(integer)
  {
    int_plus_one = integer;
    //Do something with the returned data...
    int_plus_two = int_plus_one + 1;
    return int_plus_two;
});

If you use jQuery, $.ajax returns a thenable :

$.ajax(url, options).then(function processDataFromXHR(data) {
     return data.integer;
}).then(function anotherFunction(integer){
    int_plus_one = integer;
    //Do something with the returned data...
    int_plus_two = int_plus_one + 1;
    return int_plus_two;
});