Compare: JavaScript reduce vs C# Aggregate vs Java reduce

1. Signatures

JavaScript (Array.reduce)

arr.reduce((accumulator, currentValue, index, array) => { ... }, initialValue)

C# (LINQ Aggregate)

collection.Aggregate(
    seed,
    (acc, current) => ...
)

Optional overload:

collection.Aggregate(
    seed,
    (acc, current) => ...,
    resultSelector
)

Java (Streams reduce)

stream.reduce(identity, (acc, current) -> ...)

Optional:

stream.reduce((acc, current) -> ...)

---

2. Parameter Comparison

Feature	JavaScript	C#	Java
Accumulator	Yes	Yes	Yes
Current value	Yes	Yes	Yes
Index	Yes	No	No
Original array	Yes	No	No
Initial value	Optional	Required	Optional

---

3. Example: Sum

JavaScript

arr.reduce((acc, x) => acc + x, 0);

C#

arr.Aggregate(0, (acc, x) => acc + x);

Java

Arrays.stream(arr)
      .reduce(0, (acc, x) -> acc + x);

---

4. Example: Average

JavaScript

arr.reduce((acc, x, i, arr) => acc + x / arr.length, 0);

C#

arr.Average();

Manual:

arr.Aggregate(0, (acc, x) => acc + x) / arr.Count();

Java

Arrays.stream(arr).average().getAsDouble();

Manual:

Arrays.stream(arr)
      .reduce(0, (acc, x) -> acc + x) / arr.length;

---

5. Object Accumulator Example

JavaScript

arr.reduce((acc, x) => {
  acc.sum += x;
  acc.count++;
  return acc;
}, { sum: 0, count: 0 });

C#

var result = arr.Aggregate(
    new { Sum = 0, Count = 0 },
    (acc, x) => new { Sum = acc.Sum + x, Count = acc.Count + 1 }
);

Java

var result = Arrays.stream(arr)
    .reduce(
        new int[]{0,0},
        (acc, x) -> new int[]{acc[0] + x, acc[1] + 1},
        (a, b) -> new int[]{a[0] + b[0], a[1] + b[1]}
    );

---

6. Key Differences

• JavaScript provides extra parameters (index and array).
• C# and Java keep the API minimal and functional.
• C# requires an initial value (seed), while JavaScript and Java do not.
• Java supports parallel reduction (requires combiner logic).
• C# and Java encourage immutability in reduce operations.

---

7. Mental Model

JavaScript → flexible (extra context available)
C#        → structured (LINQ-based aggregation)
Java      → functional + parallel-ready reduction

---

8. Final Mapping

JS reduce      = flexible loop with extra context
C# Aggregate   = structured accumulation
Java reduce    = functional + parallel-safe reduction

---

9. Practical Advice

• Use reduce/aggregate for combining values.
• Use map/Select for transformation instead.
• Prefer built-in helpers when available:
  • C# → Sum(), Average()
  • Java → sum(), average()