When working with array data in JavaScript or Python, transforming, combining and filtering that data is a common task. However, using explicit loops every time can make your code messy and hard to understand. Luckily, there are built-in methods for handling these operations in a simple, declarative way - namely map(), reduce() and filter(). Mastering these 3 functional programming concepts can help you write cleaner and more maintainable code.

Map for Easy Data Transformation

The map() method allows transforming each item in an array by applying a function to it. This returns a new array with the transformed values, without mutating the original.

Here’s an example doubling some numbers in JavaScript:

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

const doubled = numbers.map(x => x * 2);

// doubled is [2, 4, 6, 8, 10]

And doing the same operation in Python:

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

doubled = list(map(lambda x: x*2, numbers))

# doubled is [2, 4, 6, 8, 10]  

Map makes it easy to re-shape data without causing side effects elsewhere in your code.

Reduce for Combining Data

The reduce() method combines all the items in an array into a single value, by repeatedly applying a function. This is great for aggregating data.

Here’s an example summing an array of numbers in JavaScript:

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

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

// sum is 15

And the same operation in Python:

from functools import reduce

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

sum = reduce(lambda acc, x: acc + x, numbers)

# sum is 15

Reduce can be used for anything from calculating totals to generating reports.

Filter for Selecting Data

The filter() method returns a subset of an array, based on whether the items pass a conditional test. It’s useful for filtering out unwanted values.

Here’s an example getting only even numbers from an array in JavaScript:

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

const evens = numbers.filter(x => x % 2 === 0); 

// evens is [2, 4]

And in Python:

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

evens = list(filter(lambda x: x % 2 == 0, numbers))

# evens is [2, 4] 

Filter gives you an easy way to narrow down arrays to only the data you need.

Chaining for Data Pipelines

The real power comes when you combine these methods to transform, combine and filter data in a pipeline:

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

const pipeline = numbers
  .map(x => x * 2)
  .filter(x => x % 4 === 0) 
  .reduce((acc, x) => acc + x, 0);
  
// pipeline is 12

This allows declaratively operating on data for cleaner and more readable code.

Leveraging map(), reduce() and filter() can help simplify your code and make it more understandable and maintainable.