Javascript Recursion & # 8594; what does backtracking look like?

Question

So, I'm just starting to learn recursion and get a little fixated on concepts. Here is the solution I found for the digit function (f (126) = 1 + 2 + 6 = 9):

function sumDigits(num, sum){
if (num === 0) {
    return sum;
} else {
    sum += num % 10;
    num = Math.floor(num / 10);
    return sumDigits(num, sum);
}}

I followed it to the bottom, so far everything makes sense:

**Trace**
f(126, 0)
    {
    sum = 6
    num = 12
    f(12, 6)
    }
f(12, 6)
    {
    sum = 8
    num = 1
    f(1, 8)
    }
f(1, 8)
    {
    sum = 9
    num = 0
    f(0, 9)
    }
f(0, 9) = 9

I think it makes no sense to me HOW does the base case go back during unwinding? How exactly does he travel?

I expect facepalm, but until I understand, I don't think I can replicate this solution.

Thank you for your help!

Answer 1

sum sumDigits. , 0. , :

sumDigits(123, 0);
    return sumDigits(12, 3);
        return sumDigits(1, 5)
            return sumDigits(0, 6) // the base case (sum = 6)
                return sum;

6. . ( ). sum.

, . , , (.. , (.. )).

Answer 2

function sumDigits(num) {
    if (num < 0)
        return sumDigits(Math.abs(num)) //handle negative numbers
    least_sig_digit = num % 10
    if (num < 10)
        return least_sig_digit //in case num is a float)
    else
        return least_sig_digit + sumDigits(Math.floor(num / 10))
}

, , sumDigits , . , .

:

sumDigits(126)
= 6 + sumDigits(12)
= (6+2) + sumDigits(1)
= (6+2+1)
= 9

. , 9 sumDigits(126).

- , . , , - 5! = 5*4!, .

sumDigits(126)? 6 + sumDigits(12). sumDigits(12)? (6+2) + sumDigits(1). .

Answer 3

sum += num % 10 .

, sum, sum ( +=) , , sum . .

, . null.

, .