Correct way to return a value from Node.js function

Question

Consider the following functions where I am returning a value.

Method 1:

function getData() {
    var myData = '';
    var DateObj = new Date();
    for (i=0; i<50000; i++) {
         myData += "'" + DateObj.toString() +"', ";
    }

    return myData;
}

Method 2:

function getData(calbck) {
  try{
    var myData = '';
    var DateObj = new Date();
    for (i=0; i<50000; i++) {
         myData += "'" + DateObj.toString() +"', ";
    }
  } catch(e){
  return calbck(e,null);
  } 
  return calbck(null, myData);
}

I have tested both the ways works. Which on is the best to choose?

Thanks

Update: Tested with the following code.

function getData1() {
    var myData = '';
    var DateObj = new Date();
    for (i=0; i<50000; i++) {
         myData += "'" + DateObj.toString() +"', ";
    }
    return myData;
}

function getData2(calbck) {
  try{
    var myData = '';
    var DateObj = new Date();
    for (i=0; i<50000; i++) {
         myData += "'" + DateObj.toString() +"', ";
    }
  } catch(e){
  return calbck(e,null);
  } 
  return calbck(null, myData);
}

console.log('call getData1() start');
console.time('5000000-getData1()');
getData1()
console.log('call getData1() End');
console.timeEnd('5000000-getData1()');

console.log('call getData2(calbck) start');
console.time('5000000-getData2(calbck)');
getData2(function(err,Returned_value){
if(err) return console.log(err);
   //console.log(Returned_value);
   console.log('call getData2(calbck) End');
   console.timeEnd('5000000-getData2(calbck)');
});

Output:

D:\Test>node app.js
call getData1() start
call getData1() End
5000000-getData1(): 91ms
call getData2(calbck) start
call getData2(calbck) End
5000000-getData2(calbck): 76ms

D:\Test>node app.js
call getData1() start
call getData1() End
5000000-getData1(): 111ms
call getData2(calbck) start
call getData2(calbck) End
5000000-getData2(calbck): 78ms

First is the best IMO, because it's simpler. There's no reason to use callbacks in this example because your function isn't asynchronous. — robertklep
– robertklep, Commented May 23, 2013 at 9:11
testing this based on performance is really moot. The difference (as @robertklep mentioned) is that the latter function with callback is used for async execution, for example when waiting for some IO-operation to complete. — Geert-Jan
– Geert-Jan, Commented May 23, 2013 at 10:12
Here's a gist which implements a truly (though crude) asynchronous version of the example code. Still, it's a contrived example and not to be used to benchmark synchronous versus asynchronous execution. — robertklep
– robertklep, Commented May 23, 2013 at 10:15

Kendall Frey · Accepted Answer · 2013-05-23 13:09:49Z

3

It all comes down to whether your function is synchronous or asynchronous.

If your function is synchronous, and all the calculation is done immediately, use the first method.

If your function asynchronous, and it uses resources such as disk or network I/O, or ends up waiting on anything, then the second method is really the only option.

In your example, the function is synchronous, so you should use the first one.

answered May 23, 2013 at 13:09

Kendall Frey

44.6k21 gold badges113 silver badges151 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Myrne Stol · Accepted Answer · 2013-05-24 07:33:04Z

There's good reason to go use the "asynchronous" function signature, even if its current implementation is synchronous. A function named getData (and especially its implementation, which screams "stub" to me) suggests that this function may be doing I/O (network, file system) in the future. If you give the getData function an asynchronous function signature now, you're forced to make all code using getData pass a callback. And that may be a a good thing!

Changing the function signature of such a method later on can have ramifications for all code based using getData, be it directly or indirectly.

If the question would be about a hypothetical computeSum function, and what method signature to give that, I'd definitely recommend to use a synchronous function signature. But now, it's not so clear.

In general, I'd give any function I write an asynchronous signature (or have it return a promise) if I see a good chance that its implementation will do I/O in the future, even if its current implementation does not.

Collectives™ on Stack Overflow

Correct way to return a value from Node.js function

2 Answers 2

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related