Function Expression (Factorial)



<Below this line, add a link to the EXACT exercise that you are stuck at.>

<Below this line, in what way does your code behave incorrectly? Include ALL error messages.>
What’s the difference between these two:

return (n * (n - 1));

return (n * factorial(n - 1));

Also, the exercises Function Declaration and Function Expression let me pass even using just (n - 1). It was only after I saw the “hints” section that I realized there was code missing.


const factorial = (n) => {
if ((n === 0) || (n === 1)) {
return 1;
else {
return (n * factorial(n - 1));


<do not remove the three backticks above>


Does the lesson expect us to use recursion? (Please post a link to the exercise. Thanks.)

Let n equal 7. The above will return 42.

This one will return 5040 after filling the call stack with 7 returns. When the base case is reached, recursion stops and the stack winds down. That is when the multiplication takes place. Notice the base case returns 1, and not a function call. That is the signal to wind down the stack.


What’s recursion? Link posted.


When a function calls itself. In the above we call the function with a value for n The return is,

return n * factorial(n - 1)

On the first return, the expression, 7 * factorial(6) goes into the call stack. On the second return, 6 * factorial(5) goes into the stack. This repeats until we get to the base case, return 1.

Winding down the stack we get 1 * 2 * 3 * 4 * 5 * 6 * 7 which gives, 5040.

The funny thing is that I predicted this quesiton would come up while beta testing the new course module.


Let me see if I got this right. The “factorial” part of “factorial(n - 1)” is not a reference to the name of the current function I wrote but it’s like another sort of built-in function that works by filling the call stack with multiple returns?


It is in fact a reference to the same function, but with a different argument. Rather than return to the caller, it gets held in abeyance in the call stack. That is the internal object, a dedicated part of memory reserved for this purpose.

Here is another example to study…

function digit_sum(n) {
    if (n === 0) {
        return 0;                                      // base case
    } else {
        return n % 10 + digit_sum(Math.floor(n / 10)); // recursive case

console.log(digit_sum(123456789));    // -> 45

It is written in ES5, but can be easily refactored to an ES6 arrow function.


This topic was automatically closed 7 days after the last reply. New replies are no longer allowed.