Building Your Own Map, Filter, and Reduce in JavaScript

In this post, we delve deep into the inner workings of these JavaScript powerhouses. We won't just use them; we'll deconstruct and reconstruct them, crafting our own custom map, filter, and reduce methods using Array.prototype. By dissecting these functions, you'll gain invaluable insights into their operations, equipping you to leverage JavaScript's array manipulation capabilities adeptly.

Custom Map method:

The map method in JavaScript is instrumental for transforming arrays by applying a function to each element. Let's create a custom map method using Array.prototype:

// Custom map method for arrays
Array.prototype.customMap = function(callback) {
  const result = [];

  for (let i = 0; i < this.length; i++) {
    result.push(callback(this[i], i, this));
  }

  return result;
};

// Example usage:
const numbers = [1, 2, 3, 4, 5];
const doubledNumbers = numbers.customMap((num) => num * 2);
console.log(doubledNumbers); // [2, 4, 6, 8, 10]

In this custom map method, we iterate over each element of the input array, apply the provided callback function to each element, and push the result into a new array, which is then returned.

Custom filter Method:

The filter method enables the creation of a new array containing elements that satisfy a specific condition. Let's create a custom filter method using Array.prototype:

// Custom filter method for arrays
Array.prototype.customFilter = function(callback) {
  const result = [];

  for (let i = 0; i < this.length; i++) {
    if (callback(this[i], i, this)) {
      result.push(this[i]);
    }
  }

  return result;
};

// Example usage:
const numbers = [1, 2, 3, 4, 5];
const evenNumbers = numbers.customFilter((num) => num % 2 === 0);
console.log(evenNumbers); // [2, 4]

In this custom filter method, we iterate over each element of the input array, apply the provided callback function to each element, and if the callback returns true, we add the element to the result array, which is then returned.

Custom reduce Method:

Creating a custom reduce method involves handling an initial value. Let's create a custom reduce method using Array.prototype:

// Custom reduce method for arrays
Array.prototype.customReduce = function(callback, initialValue) {
  let accumulator = initialValue === undefined ? this[0] : initialValue;
  const startIndex = initialValue === undefined ? 1 : 0;

  for (let i = startIndex; i < this.length; i++) {
    accumulator = callback(accumulator, this[i], i, this);
  }

  return accumulator;
};

// Example usage:
const numbers = [1, 2, 3, 4, 5];
const sum = numbers.customReduce((accumulator, current) => accumulator + current, 0);
console.log(sum); // 15

Now, we have a customReduce method that can be used on any array. In this custom reduce method, we iterate over the array, starting from either the provided initialValue or the first element if no initial value is provided. We apply the callback function to each element, updating the accumulator value at each step, and finally return the accumulated result.

Conclusion:

Understanding the inner workings of JavaScript’s array methods such as map, filter, and reduce is essential for proficient JavaScript development. By creating custom versions of these methods using Array.prototype, we've gained insights into their underlying principles. These custom methods not only aid in conceptual understanding but also underscore the versatility and power of JavaScript as a programming language.