Infinite Method Object - Practice Coding Problems

Infinite Method Object - Problem

JavaScript Easy

Create an Infinite Method Object

You need to write a function that returns a special object with a unique property: any method you call on it will return the name of that method as a string.

This "infinite method object" should dynamically handle method calls that don't actually exist, using JavaScript's powerful meta-programming capabilities. When you call obj.someMethod(), it should return "someMethod". When you call obj.abc123(), it should return "abc123".

Goal: Return an object that can respond to any method name and return that method name as a string.

Example:
const obj = createInfiniteObject();
obj.hello() // returns "hello"
obj.getData() // returns "getData"
obj.method123() // returns "method123"

Input & Output

basic_usage.js — Basic Method Calls

$ Input: const obj = createInfiniteObject(); obj.hello() obj.getData() obj.test123()

› Output: "hello" "getData" "test123"

💡 Note: The infinite object returns the exact method name that was called, regardless of what the method name is.

complex_names.js — Complex Method Names

$ Input: const obj = createInfiniteObject(); obj.getUserById() obj.calculateTotalPrice() obj.method_with_underscores() obj.camelCaseMethod()

› Output: "getUserById" "calculateTotalPrice" "method_with_underscores" "camelCaseMethod"

💡 Note: The object handles any valid JavaScript property name, including camelCase, snake_case, and mixed formats.

edge_cases.js — Edge Cases

$ Input: const obj = createInfiniteObject(); obj['special-method']() obj['123numeric']() obj.$dollarMethod() obj._privateMethod()

› Output: "special-method" "123numeric" "$dollarMethod" "_privateMethod"

💡 Note: Even special characters and bracket notation work, as the Proxy intercepts all property access patterns.

Visualization

Tap to expand

Understanding the Visualization

Method Call Made

User calls obj.someMethod() - like asking receptionist for 'John'

Proxy Intercepts

Proxy catches the call before it reaches the object - like receptionist hearing the request

Dynamic Response

Proxy returns a function that will return 'someMethod' - like receptionist saying 'connecting you to John'

Function Executes

The returned function is called and returns the method name - like completing the connection

Key Takeaway

🎯 Key Insight: JavaScript's Proxy acts like a universal interceptor that can handle any property access dynamically, making it perfect for creating objects with infinite methods without consuming memory for unused methods.

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each method call is intercepted and handled in constant time

✓ Linear Growth

Space Complexity

O(1)

Only stores the proxy handler, no matter how many methods are called

✓ Linear Space

Constraints

The function must return an object that works with any valid JavaScript property name
Method calls should return the method name as a string
The solution should handle an infinite number of different method names
Method names can contain letters, numbers, underscores, and dollar signs
Must work with both obj.methodName() and obj['method-name']() syntax

Asked in

G Google 15 f Meta 12 a Amazon 8 ⊞ Microsoft 6

The optimal solution uses JavaScript's Proxy object to intercept method calls dynamically. The Proxy's get trap catches any property access and returns a function that returns the property name. This elegant approach handles infinite method names with O(1) time and space complexity, making it far superior to pre-defining methods manually.

Common Approaches

Approach	Time	Space	Notes
✓ Proxy-based Dynamic Handler (Optimal)	O(1)	O(1)	Use JavaScript Proxy to intercept and handle any method call dynamically
Pre-defined Methods Approach	O(1)	O(n)	Manually define common method names that return their own name

Proxy-based Dynamic Handler (Optimal) — Algorithm Steps

Create a target object (can be empty)
Define a handler with a 'get' trap function
In the get trap, return a function that returns the property name
Create and return a new Proxy with the target and handler

Visualization

Tap to expand

Step-by-Step Walkthrough

Method Call

User calls obj.someMethod()

Proxy Intercepts

Proxy's get trap catches 'someMethod'

Return Function

Returns function that returns 'someMethod'

Function Executed

Function is called and returns method name

Code -

solution.c — C

// C cannot implement this pattern
// C lacks object-oriented features and dynamic method dispatch
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

// This is not possible to implement properly in C
// C does not support dynamic method creation or proxy patterns

typedef struct {
    char* (*call)(char* methodName);
} InfiniteObject;

char* dynamicCall(char* methodName) {
    char* result = malloc(strlen(methodName) + 1);
    strcpy(result, methodName);
    return result;
}

InfiniteObject* createInfiniteObject() {
    InfiniteObject* obj = malloc(sizeof(InfiniteObject));
    obj->call = dynamicCall;
    return obj;
}

int main() {
    InfiniteObject* obj = createInfiniteObject();
    printf("%s\n", obj->call("hello"));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each method call is intercepted and handled in constant time

✓ Linear Growth

Space Complexity

O(1)

Only stores the proxy handler, no matter how many methods are called

✓ Linear Space

Constraints

The function must return an object that works with any valid JavaScript property name
Method calls should return the method name as a string
The solution should handle an infinite number of different method names
Method names can contain letters, numbers, underscores, and dollar signs
Must work with both obj.methodName() and obj['method-name']() syntax

28.4K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Proxy-based Dynamic Handler (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler