That is true but it has nothing to do with recursion. That is just how arrays work. For an array, count will always be the same, human or JS. The difference is indexing  humans tend to 1index while computers and computer languages tend (afaik) to always 0index.
Notice that multiply(arr, n) == multiply(arr, n  1) * arr[n  1]
.
What that is trying to say is that the function is selfreferential. It’s like a fractal. Or sometimes they’ll have a silly magazine cover of a guy holding a magazine whose cover is him holding a magazine whose cover is him holding a magazine whose cover is him holding a magazine … Or like in Inception, where they can incept a dream inside a dream, inside a dream, inside a dream … Or like when in high school you all got stoned and someone said, "Dude, what if the atoms in our bodies are just little solar systems and there are little people living there and their atoms are just little solar systems with people and their atoms…
These are examples of one dimensional recursion. And arrays are one dimensional data objects.
So, back to the above quote. What it is saying is that if you have an array like:
const arr = [2, 5, 4, 3]
and we have a function called multiply that will multiply the first n elements, then
multiply(arr, n)
should be the same as
2 * 5 * 4 * 3
and
multiply(arr, n  1) * arr[n  1]
is (substituting in)
multiply(arr, 3) * 3
so really, that is saying
2 * 5 * 4 * 3 === (2 * 5 * 4) * 3
which is the associative property that we all leaned in grade school (and then most of us forgot.)
but notice that here that this:
multiply(arr, n) == multiply(arr, n  1) * arr[n  1]
is calling itself  the function call on the right side is calling itself on the left side, but with a decremented n. So, what if we continued our expansion on the right side. We start with:
multiply(arr, 4) == multiply(arr, 3) * arr[3]
becomes
multiply(arr, 4) == multiply(arr, 3) * 3
expands to
multiply(arr, 4) == (multiply(arr, 2) * 4) * 3
expands to
multiply(arr, 4) == ((multiply(arr, 1) * 5) * 4) * 3
expands to
multiply(arr, 4) == ((((multiply(arr, 0) * 2) * 5) * 4) * 3
Now we reach the place where we want to stop because we have worked through the array. This is called the “base case”. This is the point where we have reached the end and we want to stop making recursive calls and start returning things.
Keep in mind that not a single function call has completed. The couldn’t complete because they couldn’t return until the next function call was complete, on and on. We have a bunch of incomplete calls on the call stack. But now we are at the base case and can finally return something:
if (n <= 0) {
return 1;
So we get:
multiply(arr, 4) == (((((1) * 2) * 5) * 4) * 3
We can remove the parentheses because of the associative property and we can remove the 1 because of the associative property and we can get rid of the 1 because of the identity property of multiplication, so we are left with:
multiply(arr, 4) == 2 * 5 * 4 * 3
which is what we wanted. Note that the right side no longer has any function calls, so it can complete. The call stack will “unravel” and those calls stored on the call stack will return a value so each incomplete call will complete and return a value to the call below it so that it can complete and return a value to the call below it so that … on and on until all the function calls are complete and we have our answer.
Is this complicated? Yes. Is it weird to think this way? Yes. Will it take a (long) while to fully understand? Yes.
Do we need recursion? Not really. There is no problem that can be solved with recursion that can’t be solved without recursion.
Wait, then why learn it?!?!

It is excellent training for your coder brain. It requires a deeper understanding of data structures and algorithms and how functions work.

The sometimes show up on interviews.

There are types of problems that are soooo much easier to solve with recursion. These often involve data structures like linked lists, trees, and graphs.
But don’t get frustrated. Do your best, realize that this is difficult stuff, and accept that understanding recursion will be a longterm goal.