JavaScript's reduce method is a powerful tool for performing operations on arrays. It enables you to iterate over an array and accumulate a single value, such as a sum, average, flattened array, or even a transformed structure. This blog post dives into various use cases of reduce to demonstrate its versatility.
1. Summing Array Elements
One of the most common uses of reduce is summing up all elements in an array.
let a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let y = a.reduce((acc, val) => {
console.log('acc', acc, '--------', 'val', val);
return acc + val;
});
console.log(y); // Output: 55
Here, acc accumulates the sum of the elements as the loop iterates through the array.
2. Calculating the Average
Using reduce, you can calculate the average of an array by keeping track of the current index and the total number of elements.
let a1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let y1 = a1.reduce((acc, val, i, { length: len }) => {
console.log('acc', acc, '--------', 'val', val);
return i == len - 1 ? (acc + val) / len : acc + val;
});
console.log(y1); // Output: 5.5
The final division occurs only when we reach the last element.
3. Flattening an Array
reduce can also be used to flatten nested arrays into a single-level array.
let a2 = [1, 2, 3, [3, 4, 5], [6]];
let y2 = a2.reduce((acc, val) => acc.concat(val), []);
console.log(y2); // Output: [1, 2, 3, 3, 4, 5, 6]
The concat method merges nested arrays into a single-level array during the reduction process.
4. Transforming an Array into an Object
Transform an array of objects into a single object with keys derived from object properties.
let a3 = [
{ id: 1, name: 'A' },
{ id: 2, name: 'B' },
{ id: 3, name: 'C' }
];
let y3 = a3.reduce((acc, val) => {
return { ...acc, [val.id]: val };
}, {});
console.log(y3);
/* Output:
{
1: { id: 1, name: 'A' },
2: { id: 2, name: 'B' },
3: { id: 3, name: 'C' }
}
*/
This is particularly useful for creating a lookup table from an array.
5. Counting Occurrences
reduce can count the frequency of elements in an array.
let a4 = ['a', 'b', 'v', 'a', 'a', 'b'];
let y4 = a4.reduce((acc, val) => {
acc[val] ? acc[val] = acc[val] + 1 : acc[val] = 1;
return acc;
}, {});
console.log(y4); // Output: { a: 3, b: 2, v: 1 }
This example is perfect for counting duplicate values in an array.
6. Applying a Series of Functions
reduce can apply a series of transformations or calculations sequentially.
let discount = (price) => price / 2;
let tax = (price) => price * 0.2;
let giftwrap = (price) => price + 5;
let delivery = (price) => price + 10;
let total = [discount, tax, giftwrap, delivery];
let finalprice = total.reduce((price, fn) => fn(price), 10);
console.log(finalprice); // Output: 15
Here, the initial price (10) undergoes sequential transformations defined in the total array of functions.
Final Thoughts
The reduce method is a versatile and powerful tool for array manipulation. From simple sums to complex transformations, it allows you to write concise and readable code. By understanding its flexibility, you can unlock many possibilities for data processing in your JavaScript projects.
Try out the examples above and let us know how reduce has made your coding life easier! Happy coding!
