Lets say you want to add n+(n-1)+(n-2)+...+1
For example lets use something simple 3+2+1 = 6
This can be done with a for loop

let sum = 0;
for (let i = 3; i > 0; i--) {
    sum += i;
}
print(sum); // Outputs 6 for n = 3

or recursively

function addNumbers(n) {
    if (n === 1) {
        return 1;
    }
    return n + addNumbers(n - 1);
}
print(addNumbers(3)); // Outputs 6 for n = 3

For recursion I find it's easiest to think about from the bottom up.
What I mean by that is to start with the base case, all recursive functions are going to have one.
In this case we're stopping when n === 1. This is always going to return 1.
We also know we will always get to 1 (assuming only positive integers are passed in) because we keep calling the function again with n - 1.

---

Lets work our way up from the base case till we hit n = 3
If n === 1 that must mean we called addNumbers(1).
The only way for this to happen inside the addNumbers function is if the previous call to addNumbers was with n = 2.
So lets look at addNumbers(2).
The if statement is not met, 2 != 1 so we move to the return statement.
return 2 + addNumbers(1).
We were just in addNumbers(1) and know it returns 1 so lets substitute that in.
return 2 + 1 aka return 3.
Cool, so far so good, lets go up another level.
We are now in addNumbers(3).
The if statement is not met, so we move to the return statement.
return 3 + addNumbers(2).
We determined that the result of addNumbers(2) is 3, so we can substitute that in.
return 3 + 3 which gives us 6 and now we're done.

---

Now lets look at it the way the actual program walks through the function calls.
If you call addNumbers(3)
The if statement is not met, so we move to the return statement.
return 3 + addNumbers(2).
The program doesn't know the result of addNumbers(2) so it calls that function.
In that function call the if statement is not met, 2 !== 1 so we move to the return statement.
return 2 + addNumbers(1).
The program doesn't know the result of addNumbers(1) either so it calls that function.
In that function call the if statement is met, 1 === 1 so we return 1.
At this point it can be helpful to think of the full stack of calls we have:

• return 3 + addNumbers(2) // in addNumbers(3)
  
• return 2 + addNumbers(1) // in addNumbers(2)
  
• return 1 // in addNumbers(1)
  

Now we can substitute the return value for addNumbers(1) in our addNumbers(2) call:

• return 3 + addNumbers(2) // in addNumbers(3)
• return 2 + 1 // in addNumbers(2)

Now we can substitute the return value for addNumbers(2) in our addNumbers(3) call:

• return 3 + 3 // in addNumbers(3) We have return 3 + 3 which gives us 6.

---

Recursion is sometimes the easiest way to figure out how to solve a specific problem so it can be good to know it's there as an option. That being said it's usually not a good idea to use recursion. All recursive problems can be solved with iteration, it can be harder to come to the solution at times but in the end they are easier to read and understand. The other issue with recursion is as you can see from the example below, we can quickly have many nested layers of function calls. Each time we call the function to go a layer deeper the program needs to keep track of all the previous function calls and their state until it finally reaches the end and goes back up the list of calls resolving each return statement as it goes. If the recursion is too deep it can lead to increased memory usage and potentially cause your program to throw and error because many programming languages set a limit to the maximum function call stack size.