I'm refactoring a large javascript document that I picked up from an open source project. A number of functions use inconsistent return statements. Here's a simple example of what I mean:
var func = function(param) { if (!param) { return; } // do stuff return true; }
Sometimes the functions return boolean, sometimes strings or other things. Usually they are inconsistently paired with a simple return;
statement inside of a conditional.
The problem is that the code is complex. It is a parser that uses a multitude of unique RegEx matches, creates and destroys DOM nodes on the fly, etc. Preliminary testing shows that, in the above example, I could change the return;
statement to become return false;
, but I'm concerned that I may not realize that it had a negative impact (i.e. some feature stopped working) on the script until much later.
So my questions: Is there a benefit to using a blank return statement? Could this have been intentionally coded this way or was it just lazy? Can I change them all to return false;
, or return null;
or do I need to dig through every call and find out what they are doing with the results of those functions?
A return statement is the way a function provides that result. There's no other way to do that, so it's not a matter of style; if your function has a useful result, you need a return statement. In some cases, you're only calling a function for its side-effects, and there is no useful result.
A return statement ends the execution of a function, and returns control to the calling function. Execution resumes in the calling function at the point immediately following the call. A return statement can return a value to the calling function.
No; that is not needed. You only need to write return; if you want to return early and skip the rest of the function. Show activity on this post. You are correct, return; is never needed in a function that is not breaking out of itself early.
Using return
without a value will return the value undefined
.
If the value is evaluated as a boolean, undefined
will work as false
, but if the value for example is compared to false
, you will get a different behaviour:
var x; // x is undefined alert(x); // shows "undefined" alert(!x); // shows "true" alert(x==false); // shows "false"
So, while the code should logically return true
or false
, not true
or undefined
, you can't just change return;
to return false;
without checking how the return value is used.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With