Make Object Immutable - Practice Coding Problems

Make Object Immutable - Problem

JavaScript Medium

Write a function that takes an object obj and returns a new immutable version of this object. An immutable object is an object that can't be altered and will throw an error if any attempt is made to alter it.

There are three types of error messages that can be produced from this new object:

Attempting to modify a key on the object will result in this error message: Error Modifying: ${key}
Attempting to modify an index on an array will result in this error message: Error Modifying Index: ${index}
Attempting to call a method that mutates an array will result in this error message: Error Calling Method: ${methodName}

You may assume the only methods that can mutate an array are ['pop', 'push', 'shift', 'unshift', 'splice', 'sort', 'reverse'].

obj is a valid JSON object or array, meaning it is the output of JSON.parse().

Note: A string literal should be thrown, not an Error.

Input & Output

Example 1 — Object Property Modification

$ Input: obj = {"name": "John", "age": 30}

› Output: Attempting obj.name = "Jane" throws "Error Modifying: name"

💡 Note: The immutable object prevents property modification and throws the specific error message

Example 2 — Array Index Modification

$ Input: obj = [1, 2, 3]

› Output: Attempting obj[0] = 5 throws "Error Modifying Index: 0"

💡 Note: Array index modifications are blocked with index-specific error message

Example 3 — Array Method Call

$ Input: obj = [1, 2, 3]

› Output: Attempting obj.push(4) throws "Error Calling Method: push"

💡 Note: Mutating array methods are overridden to throw method-specific errors

Constraints

obj is a valid JSON value
obj can be an object, array, or primitive value
All nested structures must be made immutable
Must throw string literals, not Error objects

Visualization

Tap to expand

Understanding the Visualization

Input

Mutable JavaScript object or array

Process

Wrap with protection mechanism

Output

Immutable version that throws on modification

Key Takeaway

🎯 Key Insight: Proxy intercepts all operations to provide immutability with custom error messages

Asked in

G Google 25 f Facebook 20 M Microsoft 15

The key insight is using JavaScript Proxy to intercept all property access and modification attempts. The optimal approach creates recursive Proxy wrappers that throw specific error messages for different modification types. Time: O(n), Space: O(n)

Common Approaches

Approach	Time	Space	Notes
✓ Object.freeze Approach	O(n)	O(1)	Use Object.freeze recursively to prevent modifications
Proxy-based Immutability	O(n)	O(n)	Use JavaScript Proxy to intercept and control all property access

Object.freeze Approach — Algorithm Steps

Step 1: Recursively freeze all nested objects and arrays
Step 2: Override array mutating methods to throw custom errors
Step 3: Return the frozen object

Visualization

Tap to expand

Step-by-Step Walkthrough

Input Object

Original mutable object

Apply Freeze

Recursively freeze all properties

Immutable Result

Object throws errors on modification

Code -

solution.c — C

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

char* solution(char* obj) {
    // C doesn't have objects or JSON support
    // Return input as-is
    return obj;
}

int main() {
    char obj[1000];
    fgets(obj, sizeof(obj), stdin);
    obj[strcspn(obj, "\n")] = 0;
    printf("%s\n", solution(obj));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each property once in the object tree

✓ Linear Growth

Space Complexity

O(1)

Only modifies existing object structure

✓ Linear Space

23.4K Views

Medium Frequency

~25 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

Object.freeze Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler