Imagine you are going to add up the value of a small bag of coins. First you reach into the bag with both hands, and retrieve 1 coin in each hand. We’ll make your left hand the `accumulator`

and your right hand the `currentValue`

. First you look at the coin in your left hand `accumulator`

, and note its value, then you place the coin currently in your right hand `currentValue`

into your left hand `accumulator`

with the coin that’s already there, and add its value to the previous total. Now your left hand `accumulator`

has 2 coins, and your right hand is empty. You reach back into the bag with only your right hand `currentValue`

to get the next coin. Then you move the coin to you left hand `accumulator`

adding it’s value to the previous total. Now your left hand `accumulator`

has 3 coins, and your right hand `currentValue`

is once again empty. You repeat this process until you’ve accumulated all of the coins into your left hand `accumulator`

, and you know the total value of the coins that were in the bag. It’s important to note that the `reduce()`

method does not change the original array, so at the end of my analogy, the coins would be paced back in the bag. Also, `reduce()`

isn’t limited to addition.

Consider this very simple example, and its results:

```
const myArray = [2, 2, 2, 2];
console.log(myArray.reduce((a,b) => a + b));
console.log(myArray.reduce((a,b) => a - b));
console.log(myArray.reduce((a,b) => a * b));
console.log(myArray.reduce((a,b) => a / b));
```

Output:

8

-4

16

0.25

Hope this helps.