Hi @daniel_Landau,
Two ideas are expressed in that line of code:
1.- A recursive definition of sum
2.- How to “access” a limited number of element(s) of an array using an index number
We can express the same ideas in other ways:
2.- How to “access” elements of an array (without using an index number)
To avoid the use of a index number, we can use the first and rest approach.
The idea is mimic when people take things out of a box: they usually take them out one a a time (first), leaving the other things (rest) inside the box (array).
You can implement first and rest in JS using a destructuring assignment[0] :
let arr = ["A","B","C","D","E"];
const [first, ...rest] = arr;
console.log("first:",first);
console.log("rest:",rest);
// first: A
// rest: [ 'B', 'C', 'D', 'E' ]
Using that approach you can access every element of an array:
As you can see in the gif, if you apply first and rest on an empty array you get undefined and an empty array (infinite):
let arr = [];
const [first, ...rest] = arr;
console.log("first:",first);
console.log("rest:",rest);
// first: undefined
// rest: []
To avoid that, you can use a condition.
1.- A recursive definition of sum
We can define sum recursively (using first and rest ) as:
/**
* Returns the sum of every number in the array
* If the array is empty, return 0;
* @param {array} arr - the array of numbers
* @returns {number} - the sum of every number in the array or zero
*/
function sum(arr) {
if(arr.length === 0) return 0; // A condition (to avoid infinite recursive calls)
const [first, ...rest] = arr;
return first + sum(rest);
}
console.log(sum([0])); // 0
console.log(sum([1])); // 1
console.log(sum([0,1])); // 1
console.log(sum([1,2])); // 3
console.log(sum([1,-1])); // 0
As you can see, the above sum is applied to every element of the array.
To limit to n elements:
function sum(arr, n) {
const [first, ...rest] = arr;
if (n <= 0) return 0; // I changed the base case
return first + sum(rest, n-1); // without n-1 the base case is never reached
}
console.log(sum([1], 0)); // 0
console.log(sum([2, 3, 4], 1)); // 2
console.log(sum([2, 3, 4, 5], 3)); // 9
Conclusion
a.- I think that a sum function that apply to every element of the array is easier to understand than a sum function that only apply to some elements of the array.
b.- The part “… that returns the sum of the first n elements of an array arr” seems superfluous and arbitrary.
c. I read :
function sum(arr) {
if(arr.length === 0) return 0;
const [first, ...rest] = arr;
return first + sum(rest);
}
As:
The sum of all elements of an array is: the first element of the array plus the (result of the) sum of the rest of elements of the array.
Cheers and happy coding 
Notes:
[0] Destructuring assignment - JavaScript | MDN
