Array Prototype ForEach - Practice Coding Problems

Array Prototype ForEach - Problem

Javascript Easy

Write your version of method forEach that enhances all arrays such that you can call the array.forEach(callback, context) method on any array and it will execute callback on each element of the array.

Method forEach should not return anything.

callback accepts the following arguments:

currentValue - represents the current element being processed in the array. It is the value of the element in the current iteration.
index - represents the index of the current element being processed in the array.
array - represents the array itself, allowing access to the entire array within the callback function.

The context is the object that should be passed as the function context parameter to the callback function, ensuring that the this keyword within the callback function refers to this context object.

Try to implement it without using the built-in array methods.

Input & Output

Example 1 — Basic Usage

$ Input: Array.prototype.forEach([1, 2, 3], callback)

› Output: Executes callback for each element

💡 Note: forEach calls the callback function for each element: callback(1, 0, array), callback(2, 1, array), callback(3, 2, array)

Example 2 — With Context

$ Input: Array.prototype.forEach([1, 2, 3], callback, context)

› Output: Executes callback with proper this binding

💡 Note: forEach calls callback with context binding: callback.call(context, 1, 0, array), allowing 'this' to refer to context object

Example 3 — Empty Array

$ Input: Array.prototype.forEach([], callback)

› Output: No callback executions

💡 Note: Empty array results in no callback executions, forEach handles this gracefully

Constraints

Array can be empty or contain any number of elements
Callback function must accept currentValue, index, and array parameters
Context parameter is optional
Implementation should not use built-in array methods

Visualization

Tap to expand

Understanding the Visualization

Input

Array [1,2,3,4,5] with callback function

Process

Iterate through each element calling callback(value, index, array)

Output

No return value, but callback executes for each element

Key Takeaway

🎯 Key Insight: Custom forEach implementation requires proper iteration and context binding using call() method

Asked in

G Google 25 f Facebook 20 a Amazon 15 M Microsoft 18

The key insight is implementing a custom forEach method that properly handles context binding and iterates through array elements. Best approach uses a simple for loop with proper call() method usage for context binding. Time: O(n), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Enhanced Implementation with Context Binding	O(n)	O(1)	Optimized forEach with proper context handling and edge cases
Basic For Loop Implementation	O(n)	O(1)	Simple for loop iterating through array elements

Enhanced Implementation with Context Binding — Algorithm Steps

Check for empty array
Iterate with proper context binding
Handle undefined elements gracefully
Use call() for this binding

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup Context

Initialize context object

Bind Context

Use call() to bind this context

Execute

Callback has access to context

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    int multiplier;
    char results[10][150];
    int resultCount;
} TestContext;

typedef void (*ContextForEachCallback)(int value, int index, int* array, int length, TestContext* context);

void forEachImpl(int* arr, int length, ContextForEachCallback callback, TestContext* context) {
    if (length == 0) return;
    
    for (int i = 0; i < length; i++) {
        callback(arr[i], i, arr, length, context);
    }
}

void contextCallback(int value, int index, int* array, int length, TestContext* context) {
    int result = value * context->multiplier;
    sprintf(context->results[context->resultCount], "Index %d: %d * %d = %d", index, value, context->multiplier, result);
    context->resultCount++;
}

int main() {
    int testArray[] = {1, 2, 3, 4, 5};
    int length = 5;
    
    TestContext context = {2, {}, 0};
    
    forEachImpl(testArray, contextCallback, &context);
    
    printf("[");
    for (int i = 0; i < context.resultCount; i++) {
        printf("\"%s\"", context.results[i]);
        if (i < context.resultCount - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Still iterates through all n elements once

✓ Linear Growth

Space Complexity

O(1)

No additional data structures, just local variables

✓ Linear Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Enhanced Implementation with Context Binding — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler