Otdfbt

Much, by keeping a running total:

function* partialSums(iterable) 
 let s = 0;

 for (const x of iterable) 
 s += x;
 yield s;
 


const x = [0, 1, 2, 3, 4, 5];
console.log(Array.from(partialSums(x)).join(', '));

Linear time, online. (You can also produce an array directly; expand below.)

const partialSums = arr => 
 let s = 0;
 return arr.map(x => s += x);
;

const x = [0, 1, 2, 3, 4, 5];
console.log(partialSums(x).join(', '));

The flat map won't be useful in your case, because you're not trying to flatten your partial results coming as lists, but we can probably try to resolve your problem in a single reduce:

[0, 1, 2, 3, 4, 5]
.reduce(
 ([arr, sum], el) => // We pass along array and running sum
 const next = sum + el
 return [[...arr, next], next]
 ,
 [[], 0] // We need to seed our reduce with empty array and accumulator for calculating running sum
)[0] // Array containing array and the last sum is returned, so we need to take only the first element

It also iterates the array only once, so it might be a little more performant, than a solution creating slices and then summing them.

Or a version with array.push, which reuses same array:

[0, 1, 2, 3, 4, 5]
.reduce(
 ([arr, sum], el) => // We pass along array and running sum
 const next = sum + el
 arr.push(next)
 return [arr, next]
 ,
 [[], 0] // We need to seed our reduce with empty array and accumulator for calculating running sum
)[0] 

Below, scan takes a mapping function f and an initial accumulator r -

const scan = (f, r, [ x, ...xs ]) =>
 x === undefined
 ? [ r ]
 : [ r, ...scan (f, f (r, x), xs) ]
 
const add = (x, y) =>
 x + y

const print = (...vs) =>
 vs .forEach (v => console .log (v))

const data =
 [ 0, 1, 2, 3, 4, 5 ]
 
print
 ( scan (add, 0, data)
 , scan (Math.max, 3, data)
 , scan (add, 0, [])
 )

// [ 0, 0, 1, 3, 6, 10, 15 ]
// [ 3, 3, 3, 3, 3, 4, 5 ]
// [ 0 ]

If you need a program that does not take an initial accumulator, the first element of the input array can be used instead. This variation is called scan1 -

const scan = (f, r, [ x, ...xs ]) =>
 x === undefined
 ? [ r ]
 : [ r, ...scan (f, f (r, x), xs) ]
 
const scan1 = (f, [ x, ...xs ]) =>
 x === undefined
 ? []
 : scan (f, x, xs)

const add = (x, y) =>
 x + y
 
const print = (...vs) =>
 vs .forEach (v => console .log (v))

const data =
 [ 0, 1, 2, 3, 4, 5 ]

print
 ( scan1 (add, data)
 , scan1 (Math.max, data)
 , scan1 (Math.min, data)
 , scan1 (add, [])
 )
 
// [ 0, 1, 3, 6, 10, 15 ]
// [ 0, 1, 2, 3, 4, 5 ]
// [ 0, 0, 0, 0, 0, 0 ]
// []

Performance optimisations can be made and stack-overflow woes can be remedied, if necessary, all without sacrificing functional style -

const scan = (f, init, xs) =>
 loop
 ( ( r = []
 , a = init
 , i = 0
 ) =>
 i >= xs.length
 ? push (a, r)
 : recur
 ( push (a, r)
 , f (a, xs[i])
 , i + 1
 )
 )

Now let's run it with a big input -

// BIG data!
const data =
 Array .from (Array (10000), (_, x) => x)

// fast and stack-safe
console .time ("scan")
const result = scan (add, 0, data)
console .timeEnd ("scan")
// scan: 8.07 ms

console .log (result)
// [ 0, 0, 1, 3, 6, 10, 15, ..., 49985001 ]

This depends on the following generic functional procedures -

const recur = (...values) =>
 ( recur, values )

const loop = f =>
 let r = f ()
 while (r && r.recur === recur)
 r = f (...r.values)
 return r


const push = (x, xs) =>
 ( xs .push (x)
 , xs
 )

Expand the snippet below to verify the results in your own browser -

const recur = (...values) =>
 ( recur, values )

const loop = f =>
 let r = f ()
 while (r && r.recur === recur)
 r = f (...r.values)
 return r


const push = (x, xs) =>
 ( xs .push (x)
 , xs
 )

const scan = (f, init, xs) =>
 loop
 ( ( r = []
 , a = init
 , i = 0
 ) =>
 i >= xs.length
 ? push (a, r)
 : recur
 ( push (a, r)
 , f (a, xs[i])
 , i + 1
 )
 )

const add = (x, y) =>
 x + y

const data =
 Array .from (Array (10000), (_, x) => x)
 
console .time ("scan")
const result = scan (add, 0, data)
console .timeEnd ("scan")

console .log (result)
// [ 0, 0, 1, 3, 6, 10, 15, ..., 49995000 ]

You can simply use a for loop with a variable to keep track of the last sum

let x = [ 0, 1, 2, 3, 4, 5 ]

let sum = (arr) => 
 let sum = 0
 let final = []
 for(let i=0; i<arr.length; i++)
 sum+= arr[i]
 final.push(sum)
 
 return final


console.log(sum(x))

You can also use map:

let x = [0, 1, 2, 3, 4, 5]

let sum = (arr) => 
 let sum = 0
 return arr.map(current => sum += current )


console.log(sum(x))

You just need to add in every step the current value to the previous result, so you could use a simple reduce.

const array = [0, 1, 2, 3, 4, 5, 6];

const sums = array.reduce((acc,current,index) => 
 const prev = acc.length ? acc[index-1] : 0;
 acc.push(prev + current);
 return acc;
,[]);

console.log(sums.toString());

If you asking is there a faster or more efficient way then the other answers are sufficient.

However, I'd argue that something similar to your current solution is easier to read and more declarative if we phrase it as a mapping function.

Specifically something like "Map each value to itself plus all the previous values in the array".

You could use a filter, as you have done in your question, but i think a slice is clearer.

const x = [ 0, 1, 2, 3, 4, 5 ];

// A common generic helper function
const sum = (acc, val) => acc + val

const sums = x.map((val, i, self) => val + self.slice(0, i).reduce(sum, 0))

It's possible to use map directly, if you keep an external accumulator variable:

const x = [ 0, 1, 2, 3, 4, 5 ];

let acc = 0;
const prefixSum = x.map(x => acc += x);

console.log(prefixSum);

One option is to use a single .map which uses .reduce inside to sum up the sliced partial array:

const x = [0, 1, 2, 3, 4, 5];

const sum = (x, y) => x + y;
const partialSums = x.map((_, i, arr) => arr.slice(0, i + 1).reduce(sum));
console.log(partialSums);

Here is a simple answer using a recursive function.

var array = [ 0, 1, 2, 3, 4, 5 ];

function sumArray(arrayToSum, index)
 if(index < arrayToSum.length-1)
 arrayToSum[index+1] = arrayToSum[index] + arrayToSum[index+1];
 return sumArray(arrayToSum, index+1);
 else
 return arrayToSum;


sumArray(array, 0);

console.log(array);

A way can be to use for each and then slice the arrays to get the elements one by one and then sum them all by array.reduce You can do this like

let x = [0, 1, 2, 3, 4, 5]
let sum = []
x.forEach((_, index) => 
 index++;
 sum.push(x.slice(0, index).reduce((a, b) => a + b))
)
console.log(sum)

We are getting [0] then [0,1] then [0,1,2] then [0,1,2,3] and via [0,1,2].reduce((a, b) => a + b)) we get 3. Just push that to a new array. Which is your answer.

We can go even shorter by doing this. To me, this seems a very optimized solution.

let ar = [0, 1, 2, 3, 4, 5]
let s = 0
let arr = []
ar.forEach((n, i) => arr.push(s += n))
console.log(arr)

Now what this does is we take a variable and then add the values to it and then simply push that to the array.