  # Array.prototype.reduce()

### Examples

Here are some examples of how to use the reduce() method:

``````// Calculate the sum of an array of numbers
const numbers = [1, 2, 3, 4, 5]
const sum = numbers.reduce((total, number) => total + number, 0)
console.log(sum) // 15
``````
``````// Concatenate an array of strings
const words = ['the', 'quick', 'brown', 'fox']
const sentence = words.reduce((string, word) => string + ' ' + word)
console.log(sentence) // "the quick brown fox"
``````
``````// Calculate the average of an array of numbers
const average = numbers.reduce((total, number, index, array) => {
total += number
if (index === array.length - 1) {
}
}, 0)
console.log(average) // 3
``````

### Syntax

The syntax for the `reduce()` method is as follows:

``````array.reduce(function (total, currentValue, currentIndex, array) {
// code to be executed
}, initialValue)
``````

The `reduce()` method takes in a callback function as its first argument. This function is called for each element in the array, and takes in four arguments:

• `total`: the accumulated value, which is initialized to the `initialValue` argument (if provided) or the first element in the array (if no `initialValue` is provided)
• `currentValue`: the current element being processed in the array
• `currentIndex`: the index of the current element being processed in the array
• `array`: the array the `reduce()` method was called on

The callback function should return the accumulated value for the next iteration.

### Description

The `reduce()` method executes a provided function for each value of the array (from left-to-right), and the return value of the function is used as the accumulator for the next call. The initial value for the accumulator can be provided as an optional second argument to the `reduce()` method.

For example, consider the following code:

``````const numbers = [1, 2, 3, 4, 5]
const sum = numbers.reduce((total, number) => total + number, 0)
console.log(sum) // 15
``````

In this case, the `reduce()` method is called on the `numbers` array with a callback function that adds the current element to the total. The initial value for the accumulator is set to 0. The `reduce()` method then iterates over the `numbers` array, starting with the first element (1). The callback function is called with the arguments `total` (0) and `number` (1). The callback function returns 1, which becomes the new value of the accumulator.

The `reduce()` method then moves on to the next element in the array (2) and calls the callback function with the arguments `total` (1) and `number` (2). The callback function returns 3, which becomes the new value of the accumulator. This process continues until all elements in the array have been processed, and the final value of the accumulator (15) is returned.

### Specifications

The `reduce()` method is specified in the ECMAScript specification, which is the standard for modern JavaScript. According to the specification, the `reduce()` method should behave as follows:

• If the `array` argument to the `reduce()` method is an empty array and no `initialValue` argument is provided, a TypeError should be thrown.
• If the `array` argument to the `reduce()` method is an empty array and an `initialValue` argument is provided, the `initialValue` should be returned.
• If the `array` argument to the `reduce()` method is not an empty array and no `initialValue` argument is provided, the `reduce()` method should call the callback function with four arguments: the first element of the array as the total argument, the second element of the array as the `currentValue` argument, and the index of the second element as the `currentIndex` argument, and the array as the array argument.
• If the `array` argument to the `reduce()` method is not an empty array and an `initialValue` argument is provided, the `reduce()` method should call the callback function with four arguments: the `initialValue` as the total argument, the first element of the array as the `currentValue` argument, and the index of the first element as the `currentIndex` argument, and the array as the array argument.

### Browser Compatibility

The `reduce()` method is supported in all modern browsers, including Internet Explorer 9 and above. You can use the `reduce()` method without worrying about compatibility issues in most cases.

### Similar Methods

There are several other array methods in JavaScript that are similar to the `reduce()` method, such as `map()` and `filter()`. The `map()` method creates a new array by calling a provided function on each element in the array, while the ``filter()` method creates a new array with all elements that pass a provided test function.

In contrast to these methods, the `reduce()` method returns a single value rather than a new array. This makes it useful for tasks such as calculating the sum of an array or concatenating an array of strings, but it is not as suitable for tasks that require creating a new array. For example, if you want to create a new array with the squared values of the elements in an array, you would use the `map()` method rather than the `reduce()` method.

Overall, the `reduce()` method is a useful and powerful tool for working with arrays in JavaScript. Whether you need to calculate the sum of an array, concatenate an array of strings, or perform some other operation on an array, the `reduce()` method is a flexible and efficient way to do so.