EDITED due to a total mind fart failure on my behalf…
No, the first item added to the array with unshift would be 4 (for the function in this case).
We are starting with 5, remember? and 5 -1 = 4.
Then we unshift() 4 (which puts it at the beginning of our array which starts out in the very beginning, before we call the function with 5, as:
[ ]
Then our initial value (5) is passed to the function, so we have:
[5]
Then (5-1) is passed to the function. 5-1 = 4 so now we have:
[4, 5]
Using unshift() vs push() just affects whether the 4 value the item is being placed into the array goes at the beginning or at the end of the array.
We are “counting down” from 5, not “counting up” to 5. The first value we push or unshift after our initial value of 5 will be 4 regardless of which array method we use.
Don’t confuse the indexes with the values, I know it’s easy to do and there’s a lot going on there and a lot to wrap our head around. 
Well, why don’t you listen to your own advice there Mr. a_aramini! Are you thinking about the stack and then typing about the array? Shame on you! lol… and get some sleeeep!!! lol
NEEEEEED SLEEEP!!! ERROR! ERROR! CANNOT COMPUTE… .CANNOT COMPUTE… ERROR! ERROR!.. a_aramini CANNOT COMPUTE…
The crossed out parts are wrong… I corrected it below for whoever might not know this and for the benefit of future readers…
A full night’s rest later…
You are indeed correct @colinthornton
All of the recursion calculations take place first…
We start with n = 5, and that gets put on the stack.
Think of the stack like a box or bucket, items can only go onto the top of the stack and be pulled off the top of the stack.
The stack:
| 5 | <— Top of stack
Then ( n - 1 ), n is 5 so: ( 5 - 1 ) = 4
The stack:
| 4 | <— Top of stack
| 5 | <— Bottom of stack
Then ( ( n -1 ) - 1 ), so: ( ( 5 - 1 ) - 1 ) = 3
The stack:
| 3 | <— Top of stack
| 4 |
| 5 | <— Bottom of stack
Then ( ( n -1 ) - 1 ), so ( ( 5 - 1 ) - 1 ) = 3
The stack:
| 3 | <— Top of stack
| 4 |
| 5 | <— Bottom of stack
Then ( ( ( n -1 ) - 1 ) - 1 ), so: ( ( ( 5 - 1) - 1 ) - 1 ) = 2
The stack:
| 2 | <— Top of stack
| 3 |
| 4 |
| 5 | <— Bottom of stack
Then ( ( ( ( n -1 ) - 1 ) - 1 ) - 1), so: ( ( ( ( 5 - 1) - 1 ) -1 ) - 1 ) = 1
The stack:
| 1 | <— Top of stack
| 2 |
| 3 |
| 4 |
| 5 | <— Bottom of stack
Then ( ( ( ( ( n -1 ) - 1 ) - 1 ) - 1) - 1 ), so: ( ( ( ( 5 - 1) - 1 ) - 1 ) - 1 ) - 1 ) = 0
The stack remains unchanged, we didn’t store the base case it is just a limit placed on the recursion to keep it from going to infinity or ( - infinity in this case)
| 1 | <— Top of stack
| 2 |
| 3 |
| 4 |
| 5 | <— Bottom of stack
We’re at the base case now, so bail out of the recursion stuff, forget about the 0 value, we don’t need it… lets move to the next part of the function body block.
Now we get to the unshift() part, where we start pulling values off the stack.
unshift( 1 )
array = [ 1 ]
Stack:
| 2 | <—Top of stack
| 3 |
| 4 |
| 5 | <— Bottom of stack
unshift( 2 )
array = [ 2, 1 ]
Stack:
| 3 | <—Top of stack
| 4 |
| 5 | <— Bottom of stack
unshift( 3 )
array = [ 3, 2, 1 ]
Stack:
| 4 | <— Top of stack
| 5 | <— Bottom of stack
unshift( 4 )
array = [ 4, 3, 2, 1 ]
Stack:
| 5 | <— Top of stack
unshift( 5 )
array = [ 5, 4, 3, 2, 1 ]
Stack:
|empty| ← memory pointer/references to stack not needed, memory reallocated via garbage collection
(all this is stack stuff is internal to JavaScript, the programmer need not worry about it, other than to know it exists and that the behavior affects the order unshift() or push() or whatever_method() will receive the values, methinks)
Using unshift() vs push() just affects whether the being pulled off the stack is is being placed at beginning of the array, or at the end of the array.