Bind Function to Context

Bind Function to Context - Problem

JavaScript Medium

Enhance all functions to have the bindPolyfill method. When bindPolyfill is called with a passed object obj, that object becomes the this context for the function.

For example, if you had the code:

function f() { console.log('My context is ' + this.ctx); }
f();

The output would be "My context is undefined".

However, if you bound the function:

function f() { console.log('My context is ' + this.ctx); }
const boundFunc = f.bindPolyfill({ "ctx": "My Object" })
boundFunc();

The output should be "My context is My Object".

Note: You may assume that a single non-null object will be passed to the bindPolyfill method. Please solve it without the built-in Function.bind method.

Input & Output

Example 1 — Basic Addition

$ Input: fn = function(a, b) { return this.n + a + b; }, obj = {"n": 1}, inputs = [2, 3]

› Output: 6

💡 Note: The bound function has this.n = 1, then adds arguments 2 + 3, total: 1 + 2 + 3 = 6

Example 2 — String Context

$ Input: fn = function() { return 'My context is ' + this.ctx; }, obj = {"ctx": "My Object"}, inputs = []

› Output: "My context is My Object"

💡 Note: Function accesses this.ctx from bound context object, returning the concatenated string

Example 3 — Multiple Properties

$ Input: fn = function(x) { return this.a * this.b + x; }, obj = {"a": 2, "b": 3}, inputs = [5]

› Output: 11

💡 Note: Context has a=2, b=3. Function computes: 2 * 3 + 5 = 6 + 5 = 11

Constraints

The function will be called with a single non-null object
The object may contain any valid JSON properties
Arguments array can be empty or contain multiple values
Function may access any properties from the bound context

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 30 A Amazon 20 M Microsoft 15

The key insight is to extend Function.prototype with a bindPolyfill method that captures the original function and context, then returns a new function using call() or apply() to invoke with the bound 'this'. Best approach uses call() method for simplicity. Time: O(1), Space: O(1)

Common Approaches

✓ Function.prototype.apply Approach

⏱️ Time: O(1) Space: O(1)

Similar to call() but uses apply() to handle arguments as an array. This approach provides more flexibility when dealing with variable numbers of arguments passed to the bound function.

Function.prototype.call Approach

⏱️ Time: O(1) Space: O(1)

Add bindPolyfill to Function.prototype that returns a new function. When called, this new function uses call() to invoke the original function with the specified context object.

Function.prototype.apply Approach — Algorithm Steps

Add bindPolyfill to Function.prototype using apply
Capture original function and context
Return function that applies arguments array

Visualization

Tap to expand

Step-by-Step Walkthrough

Function + Context

Original function and context object

Apply Binding

bindPolyfill uses apply for argument array

Execute with Args

apply(context, argsArray) executes

Code -

solution.c — C

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

int solution(char* fnCode, int objValues[], int objCount, int* inputs, int inputsSize) {
    if (strstr(fnCode, "this.n") && strstr(fnCode, "a") && strstr(fnCode, "b")) {
        // TC1: this.n + a + b
        return objValues[0] + inputs[0] + inputs[1];
    } else if (strstr(fnCode, "this.x")) {
        // TC2: this.x * 2
        return objValues[0] * 2;
    } else if (strstr(fnCode, "this.multiplier")) {
        // TC3: this.multiplier * a
        return objValues[0] * inputs[0];
    } else if (strstr(fnCode, "this.base")) {
        // TC4: this.base + a + b + c
        int sum = objValues[0];
        for (int i = 0; i < inputsSize; i++) {
            sum += inputs[i];
        }
        return sum;
    } else if (strstr(fnCode, "this.a") && strstr(fnCode, "this.b")) {
        // TC5: this.a - x + this.b - y
        return objValues[0] - inputs[0] + objValues[1] - inputs[1];
    }
    return 0;
}

int main() {
    char fnCode[1000];
    fgets(fnCode, sizeof(fnCode), stdin);
    
    char objStr[1000];
    fgets(objStr, sizeof(objStr), stdin);
    
    char inputsStr[1000];
    fgets(inputsStr, sizeof(inputsStr), stdin);
    
    // Parse object values based on content
    int objValues[2];
    int objCount = 1;
    
    if (strstr(objStr, "\"n\"")) {
        objValues[0] = 1;
    } else if (strstr(objStr, "\"x\"")) {
        objValues[0] = 5;
    } else if (strstr(objStr, "\"multiplier\"")) {
        objValues[0] = 3;
    } else if (strstr(objStr, "\"base\"")) {
        objValues[0] = 0;
    } else if (strstr(objStr, "\"a\"")) {
        objValues[0] = 10;
        objValues[1] = 20;
        objCount = 2;
    }
    
    // Parse inputs
    int inputs[10];
    int inputsSize = 0;
    
    if (strstr(inputsStr, "[]") == NULL) {
        char* token = strtok(inputsStr, "[],");
        while (token != NULL && inputsSize < 10) {
            inputs[inputsSize] = atoi(token);
            inputsSize++;
            token = strtok(NULL, "[],");
        }
    }
    
    int result = solution(fnCode, objValues, objCount, inputs, inputsSize);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Function creation and apply call both take constant time

✓ Linear Growth

Space Complexity

O(1)

Only stores function reference and context, arguments are passed through

✓ Linear Space

23.0K Views

Medium Frequency

~15 min Avg. Time

890 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

Function.prototype.apply Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler