I'm using Netbeans to add professional-like comments to each function, I write. So I begin each of it with /**
and then I press Enter
to let Netbeans fulfill default comment scheme for following function.
Up until now I've been using this only for PHP language and in this case Netbeans was always adding @returns {type}
part in comment scheme only, if following PHP function really included return
statement. On so called "procedures" (functions that does not return any value) this part was missing.
Today I tried the same thing for Javascript function and Netbeans added @returns {undefined}
part to comment scheme even though following function does not return anything.
This confused me. Does Netbeans suggests this way, that every Javascript function has to return anything? What should I do? Ignore (or delete) that comment scheme part or follow suggestion (if this is suggestion at all) and add return false;
in the end of such function, though it is useless for me?
undefined
. In many languages the result of the last statement is returned (more useful, IMO). These are called implicit returns.
The short answer is no.
The real answer is yes: the JS engine has to be notified that some function has finished its business, which is done by the function returning something. This is also why, instead of "finished", a function is said to "have returned".
A function that lacks an explicit return statement will return undefined
, like a C(++) function that has no return value is said (and its signature reflects this) to return void
:
void noReturn()//return type void
{
printf("%d\n", 123);
return;//return nothing, can be left out, too
}
//in JS:
function noReturn()
{
console.log('123');//or evil document.write
return undefined;//<-- write it or not, the result is the same
return;//<-- same as return undefined
}
Also, in JS, like in most every language, you're free to simply ignore the return value of a function, which is done an awful lot:
(function()
{
console.log('this function in an IIFE will return undefined, but we don\'t care');
}());
//this expression evaluates to:
(undefined);//but we don't care
At some very low level, the return is translated into some sort of jump. If a function really returned nothing at all, there would be no way of knowing what and when to call the next function, or to call event handlers and the like.
So to recap: No, a JS function needn't return anything as far as your code goes. But as far as the JS engines are concerned: a function always returns something, be it explicitly via a return
statement, or implicitly. If a function returns implicitly, its return value will always be undefined.
No, return
is not necessary.
When no return
statement is specified, undefined
is returned.
Does every Javascript function have to return a value?
No, they don't. It's true that deep in the specification, these are all slightly different:
function foo() {
}
function foo() {
return;
}
function foo() {
return undefined;
}
...but the result of calling each of them is the same: undefined
. So in pragmatic terms:
You don't have to write a return, you can just let code execution "fall off the end" of the function If you're returning undefined, specifically, you an just write return; When calling a function, you cannot tell (in code) whether execution fell off the end, ended with return;, or ended with return undefined;; they all look exactly the same to your calling code
Re the spec: Specifically, when a function's execution falls off the end, in the spec that's a "normal" completion; but return;
and return value;
are both "return" completions with an associated value (undefined
), which is (ever so slightly) different. But the difference is eliminated by the semantics of calling a function, which say:
... If result.[[Type]] is return, return NormalCompletion(result.[[Value]]). ReturnIfAbrupt(result). Return NormalCompletion(undefined).
So there's no difference you can observe in code.
No, you don't have to return something for every function. It is optional and upto how you write your code logic.
Success story sharing
void
, it returns nothing, but its signature reflects this through thevoid
return type.return;
is probably only useful if you need to return early. writingreturn undefined;
might produce different results ifundefined
resolves to a different value. Most (if not all) browsers will throw an error when you attempt to reassign undefined, but in theory, it's possible here's an example using node.jsvoid
in other languages (like C), where you can have functions likevoid do_someting(int *arg)
, but you can't have a variable with the typevoid
. In C,void
isn't really a type, so these functions don't return anything, they just jump