Algorithms Behind JavaScript Array Methods

Algorithms Behind JavaScript Array Methods.

JavaScript arrays come with various built-in methods that allow manipulation and retrieval of data in an array. Here’s a list of array methods extracted from your outline:

1. concat()
2. join()
3. fill()
4. includes()
5. indexOf()
6. reverse()
7. sort()
8. splice()
9. at()
10. copyWithin()
11. flat()
12. Array.from()
13. findLastIndex()
14. forEach()
15. every()
16. entries()
17. values()
18. toReversed() (creates a reversed copy of the array without modifying the original)
19. toSorted() (creates a sorted copy of the array without modifying the original)
20. toSpliced() (creates a new array with elements added or removed without modifying the original)
21. with() (returns a copy of the array with a specific element replaced)
22. Array.fromAsync()
23. Array.of()
24. map()
25. flatMap()
26. reduce()
27. reduceRight()
28. some()
29. find()
30. findIndex()
31. findLast()

Let me break down the common algorithms used for each JavaScript array method:

1. concat()

• Algorithm: Linear append/merge
• Time Complexity: O(n) where n is total length of all arrays
• Internally uses iteration to create new array and copy elements

// concat()
Array.prototype.myConcat = function(...arrays) {
  const result = [...this];
  for (const arr of arrays) {
    for (const item of arr) {
      result.push(item);
    }
  }
  return result;
};

2. join()

• Algorithm: Linear traversal with string concatenation
• Time Complexity: O(n)
• Iterates through array elements and builds result string

// join()
Array.prototype.myJoin = function(separator = ',') {
  let result = '';
  for (let i = 0; i 



<h3>
  
  
  3. fill()
</h3>

• Algorithm: Linear traversal with assignment
• Time Complexity: O(n)
• Simple iteration with value assignment

// fill()
Array.prototype.myFill = function(value, start = 0, end = this.length) {
  for (let i = start; i 



<h3>
  
  
  4. includes()
</h3>

• Algorithm: Linear search
• Time Complexity: O(n)
• Sequential scan until element found or end reached

// includes()
Array.prototype.myIncludes = function(searchElement, fromIndex = 0) {
  const startIndex = fromIndex >= 0 ? fromIndex : Math.max(0, this.length + fromIndex);
  for (let i = startIndex; i 



<h3>
  
  
  5. indexOf()
</h3>

• Algorithm: Linear search
• Time Complexity: O(n)
• Sequential scan from start until match found

// indexOf()
Array.prototype.myIndexOf = function(searchElement, fromIndex = 0) {
  const startIndex = fromIndex >= 0 ? fromIndex : Math.max(0, this.length + fromIndex);
  for (let i = startIndex; i 



<h3>
  
  
  6. reverse()
</h3>

• Algorithm: Two-pointer swap
• Time Complexity: O(n/2)
• Swaps elements from start/end moving inward

// reverse()
Array.prototype.myReverse = function() {
  let left = 0;
  let right = this.length - 1;

  while (left 



<h3>
  
  
  7. sort()
</h3>

• Algorithm: Typically TimSort (hybrid of merge sort and insertion sort)
• Time Complexity: O(n log n)
• Modern browsers use adaptive sorting algorithms

// sort()
Array.prototype.mySort = function(compareFn) {
  // Implementation of QuickSort for simplicity
  // Note: Actual JS engines typically use TimSort
  const quickSort = (arr, low, high) => {
    if (low  {
    const pivot = arr[high];
    let i = low - 1;

    for (let j = low; j 



<h3>
  
  
  8. splice()
</h3>

• Algorithm: Linear array modification
• Time Complexity: O(n)
• Shifts elements and modifies array in-place

// splice()
Array.prototype.mySplice = function(start, deleteCount, ...items) {
  const len = this.length;
  const actualStart = start  0) {
    // Moving elements right
    for (let i = len - 1; i >= actualStart + actualDeleteCount; i--) {
      this[i + shiftCount] = this[i];
    }
  } else if (shiftCount 



<h3>
  
  
  9. at()
</h3>

• Algorithm: Direct index access
• Time Complexity: O(1)
• Simple array indexing with boundary checking

// at()
Array.prototype.myAt = function(index) {
  const actualIndex = index >= 0 ? index : this.length + index;
  return this[actualIndex];
};

10. copyWithin()

• Algorithm: Block memory copy
• Time Complexity: O(n)
• Internal memory copy and shift operations

// copyWithin()
Array.prototype.myCopyWithin = function(target, start = 0, end = this.length) {
  const len = this.length;
  let to = target 



<h3>
  
  
  11. flat()
</h3>

• Algorithm: Recursive depth-first traversal
• Time Complexity: O(n) for single level, O(d*n) for depth d
• Recursively flattens nested arrays

// flat()
Array.prototype.myFlat = function(depth = 1) {
  const flatten = (arr, currentDepth) => {
    const result = [];
    for (const item of arr) {
      if (Array.isArray(item) && currentDepth 



<h3>
  
  
  12. Array.from()
</h3>

• Algorithm: Iteration and copy
• Time Complexity: O(n)
• Creates new array from iterable

// Array.from()
Array.myFrom = function(arrayLike, mapFn) {
  const result = [];
  for (let i = 0; i 



<h3>
  
  
  13. findLastIndex()
</h3>

• Algorithm: Reverse linear search
• Time Complexity: O(n)
• Sequential scan from end until match found

// findLastIndex()
Array.prototype.myFindLastIndex = function(predicate) {
  for (let i = this.length - 1; i >= 0; i--) {
    if (predicate(this[i], i, this)) return i;
  }
  return -1;
};

14. forEach()

• Algorithm: Linear iteration
• Time Complexity: O(n)
• Simple iteration with callback execution

// forEach()
Array.prototype.myForEach = function(callback) {
  for (let i = 0; i 



<h3>
  
  
  15. every()
</h3>

<p>Algorithm: Short-circuit linear scan<br>
Time Complexity: O(n)<br>
Stops on first false condition<br>
</p><pre class="brush:php;toolbar:false">// concat()
Array.prototype.myConcat = function(...arrays) {
  const result = [...this];
  for (const arr of arrays) {
    for (const item of arr) {
      result.push(item);
    }
  }
  return result;
};

16. entries()

• Algorithm: Iterator protocol implementation
• Time Complexity: O(1) for creation, O(n) for full iteration
• Creates iterator object

// join()
Array.prototype.myJoin = function(separator = ',') {
  let result = '';
  for (let i = 0; i 



<h3>
  
  
  17. values()
</h3>

• Algorithm: Iterator protocol implementation
• Time Complexity: O(1) for creation, O(n) for full iteration
• Creates iterator for values

// fill()
Array.prototype.myFill = function(value, start = 0, end = this.length) {
  for (let i = start; i 



<h3>
  
  
  18. toReversed()
</h3>

• Algorithm: Copy with reverse iteration
• Time Complexity: O(n)
• Creates new reversed array

// includes()
Array.prototype.myIncludes = function(searchElement, fromIndex = 0) {
  const startIndex = fromIndex >= 0 ? fromIndex : Math.max(0, this.length + fromIndex);
  for (let i = startIndex; i 



<h3>
  
  
  19. toSorted()
</h3>

• Algorithm: Copy then TimSort
• Time Complexity: O(n log n)
• Creates sorted copy using standard sort

// indexOf()
Array.prototype.myIndexOf = function(searchElement, fromIndex = 0) {
  const startIndex = fromIndex >= 0 ? fromIndex : Math.max(0, this.length + fromIndex);
  for (let i = startIndex; i 



<h3>
  
  
  20. toSpliced()
</h3>

• Algorithm: Copy with modification
• Time Complexity: O(n)
• Creates modified copy

// reverse()
Array.prototype.myReverse = function() {
  let left = 0;
  let right = this.length - 1;

  while (left 



<h3>
  
  
  21. with()
</h3>

• Algorithm: Shallow copy with single modification
• Time Complexity: O(n)
• Creates copy with one element changed

// sort()
Array.prototype.mySort = function(compareFn) {
  // Implementation of QuickSort for simplicity
  // Note: Actual JS engines typically use TimSort
  const quickSort = (arr, low, high) => {
    if (low  {
    const pivot = arr[high];
    let i = low - 1;

    for (let j = low; j 



<h3>
  
  
  22. Array.fromAsync()
</h3>

• Algorithm: Asynchronous iteration and collection
• Time Complexity: O(n) async operations
• Handles promises and async iterables

// splice()
Array.prototype.mySplice = function(start, deleteCount, ...items) {
  const len = this.length;
  const actualStart = start  0) {
    // Moving elements right
    for (let i = len - 1; i >= actualStart + actualDeleteCount; i--) {
      this[i + shiftCount] = this[i];
    }
  } else if (shiftCount 



<h3>
  
  
  23. Array.of()
</h3>

• Algorithm: Direct array creation
• Time Complexity: O(n)
• Creates array from arguments

// at()
Array.prototype.myAt = function(index) {
  const actualIndex = index >= 0 ? index : this.length + index;
  return this[actualIndex];
};

24. map()

• Algorithm: Transform iteration
• Time Complexity: O(n)
• Creates new array with transformed elements

// copyWithin()
Array.prototype.myCopyWithin = function(target, start = 0, end = this.length) {
  const len = this.length;
  let to = target 



<h3>
  
  
  25. flatMap()
</h3>

• Algorithm: Map flatten
• Time Complexity: O(n*m) where m is average mapped array size
• Combines mapping and flattening

// flat()
Array.prototype.myFlat = function(depth = 1) {
  const flatten = (arr, currentDepth) => {
    const result = [];
    for (const item of arr) {
      if (Array.isArray(item) && currentDepth 



<h3>
  
  
  26. reduce()
</h3>

• Algorithm: Linear accumulation
• Time Complexity: O(n)
• Sequential accumulation with callback

// Array.from()
Array.myFrom = function(arrayLike, mapFn) {
  const result = [];
  for (let i = 0; i 



<h3>
  
  
  27. reduceRight()
</h3>

• Algorithm: Reverse linear accumulation
• Time Complexity: O(n)
• Right-to-left accumulation

// findLastIndex()
Array.prototype.myFindLastIndex = function(predicate) {
  for (let i = this.length - 1; i >= 0; i--) {
    if (predicate(this[i], i, this)) return i;
  }
  return -1;
};

28. some()

• Algorithm: Short-circuit linear scan
• Time Complexity: O(n)
• Stops on first true condition

// forEach()
Array.prototype.myForEach = function(callback) {
  for (let i = 0; i 



<h3>
  
  
  29. find()
</h3>

• Algorithm: Linear search
• Time Complexity: O(n)
• Sequential scan until condition met

// every()
Array.prototype.myEvery = function(predicate) {
  for (let i = 0; i 



<h3>
  
  
  30. findIndex()
</h3>

• Algorithm: Linear search
• Time Complexity: O(n)
• Sequential scan for matching condition

// entries()
Array.prototype.myEntries = function() {
  let index = 0;
  const array = this;

  return {
    [Symbol.iterator]() {
      return this;
    },
    next() {
      if (index 



<h3>
  
  
  31. findLast()
</h3>

• Algorithm: Reverse linear search
• Time Complexity: O(n)
• Sequential scan from end

// concat()
Array.prototype.myConcat = function(...arrays) {
  const result = [...this];
  for (const arr of arrays) {
    for (const item of arr) {
      result.push(item);
    }
  }
  return result;
};

I've provided complete implementations of all 31 array methods you requested.

? Connect with me on LinkedIn:

Let’s dive deeper into the world of software engineering together! I regularly share insights on JavaScript, TypeScript, Node.js, React, Next.js, data structures, algorithms, web development, and much more. Whether you're looking to enhance your skills or collaborate on exciting topics, I’d love to connect and grow with you.

Follow me: Nozibul Islam

The above is the detailed content of Algorithms Behind JavaScript Array Methods. For more information, please follow other related articles on the PHP Chinese website!