In functional programming, it is common to use higher-order functions like map, filter, and reduce to process data. Iterators can be used in conjunction with these functions to transform and manipulate data in a declarative and concise way.

To begin, let’s take a look at an example where we want to double each number in an array. We can achieve this using an iterator and the map function:

const numbers = [1, 2, 3, 4, 5];

const doubledNumbers = numbers.map(num => num * 2);

console.log(doubledNumbers);
// Output: [2, 4, 6, 8, 10]

In the above code, we create an iterator over the numbers array using the map function. The map function takes a callback function as an argument, which is applied to each element in the array. In this case, the callback function multiplies each number by 2, effectively doubling each value.

Another common use case for iterators in functional programming is filtering data based on a specific condition. Let’s see an example of using an iterator with the filter function:

const numbers = [1, 2, 3, 4, 5];

const evenNumbers = numbers.filter(num => num % 2 === 0);

console.log(evenNumbers);
// Output: [2, 4]

In the above code, we use an iterator and the filter function to create a new array evenNumbers, which contains only the even numbers from the original numbers array. The callback function in the filter function checks if a number is divisible by 2 (i.e., even) and returns true, adding that number to the filtered array.

Iterators can also be used in combination with the reduce function to perform calculations or aggregations on a collection of data. Let’s see an example:

const numbers = [1, 2, 3, 4, 5];

const sum = numbers.reduce((acc, num) => acc + num, 0);

console.log(sum);
// Output: 15

In the above code, we use an iterator and the reduce function to calculate the sum of all numbers in the numbers array. The reduce function takes a reducer function and an initial value (in this case, 0). The reducer function takes an accumulator (acc) and the current value (num), and performs an addition operation. The final result is the accumulated sum.

By leveraging JavaScript iterators in functional programming, you can write code that is more expressive, easier to read, and less error-prone. Whether you are mapping, filtering, or aggregating data, iterators provide a flexible and efficient way to work with collections in a functional programming style.

#JavaScript #FunctionalProgramming