调用函数与返回函数调用-区别？

Question

If there a function, say foo :

function foo() {
    console.log('bar');
}

then in JavaScript, Is there any difference between calling a function from another function, like this:

function baz() {
    foo();
}
baz();

and returning the function call, like this:

function baz() {
    return foo();
}
baz();

both approaches give the same output (string output: 'bar').

Answer 1

If you return, then the rest of the function won't execute … but in your example there is no more code after the return line, so it makes no difference.

If you don't explicitly return a value, then you return undefined … but foo returns undefined anyway and you don't do anything with the return value of baz so it makes no difference.

There is no practical difference between your two examples.

Answer 2

You are not return any thing .you are just console.log('bar') inside the foo . its just ah calling not returning .see the original return call statement.Its give the undefined value from your second one

Second one was wrong

 function foo() { return 'bar'; //this is return the `bar` } function baz() { foo(); //its calling but not returning } console.log(baz()); 

So you need to return the function inside the another function call

 function foo() { return 'bar'; } function baz() { return foo(); //return is important to returning the value from the function } console.log(baz()); 

Answer 3

Strictly speaking, your second example is wrong in 2 ways: 1) you call return with the function that doesn't return anything 2) you doesn't check for return value, so what is the need to call it this way?

But even if you would check, it will return undefined, so no use.

Answer 4

The output is identical so there doesn't seem to be a reason to prefer one way of invoking the function over another. After all they both return by default undefined. But, I think returning the result of the function can sometimes be useful even if the return result is undefined. By returning undefined it can be captured in an if-conditional which would allow other statements to execute, as follows:

 function foo() { console.log('bar'); } function baz() { foo(); } baz(); function baz2() { return foo(); } if ( baz2() == undefined) { // execute statements ... }