The question tests whether you know functional/declarative alternatives to imperative loops.

Approach 1 — reduce (idiomatic, recommended)

const sum = (nums) => nums.reduce((acc, n) => acc + n, 0);

• Always pass the initial value 0 — without it, an empty array throws.
• O(n) time, O(1) space. This is the answer to give first.

Approach 2 — recursion

const sum = (nums) =>
  nums.length === 0 ? 0 : nums[0] + sum(nums.slice(1));

• Base case: empty array → 0. Recursive case: first element + sum of the rest.
• Clean and functional, but: slice copies the array each call → O(n²) total; and the call stack grows O(n) → stack overflow on large arrays (JS engines don't reliably do tail-call optimization).
• Better recursion uses an index instead of slice: sum(nums, i + 1) — O(n) time, still O(n) stack.

Other no-loop options

• nums.forEach(n => total += n) — technically no for, but still imperative.
• For-of is still a loop. while is still a loop.
• eval(nums.join('+')) — works, never do it (injection, slow).

What interviewers want

Lead with reduce and the 0 initial-value detail. Then show you can do recursion but know its limits — the O(n) stack and overflow risk on large inputs is the real signal. If they push, mention an explicit-stack iterative version or that production code just uses reduce.

Edge cases

• Empty array → 0 (the initial value handles it).
• Non-numbers in the array → NaN propagates; validate or coerce if needed.
• Very large arrays → recursion overflows; reduce is fine.