Make Object Immutable - Practice Coding Problems

Make Object Immutable - Problem

JavaScript Medium

Create an Immutable Object

Your task is to implement a function that transforms any JavaScript object or array into an immutable version. An immutable object is one that cannot be modified after creation - any attempt to alter it should throw a specific error message.

The Challenge:
• Transform the input object/array to prevent any modifications
• Handle three types of operations that should throw errors:
- Modifying object properties: "Error Modifying: ${key}"
- Modifying array indices: "Error Modifying Index: ${index}"
- Calling mutating array methods: "Error Calling Method: ${methodName}"

Mutating Array Methods: ['pop', 'push', 'shift', 'unshift', 'splice', 'sort', 'reverse']

Important: Throw string literals, not Error objects. The input is guaranteed to be a valid JSON object/array.

Input & Output

example_1.js — Basic Object

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

› Output: {"name": "John", "age": 30}

💡 Note: Creates an immutable version of the object. Reading properties works normally, but any attempt to modify (like obj.name = 'Jane') would throw 'Error Modifying: name'

example_2.js — Array Operations

$ Input: [1, 2, 3, 4, 5]

› Output: [1, 2, 3, 4, 5]

💡 Note: Array access works normally (arr[0] returns 1), but arr[0] = 10 throws 'Error Modifying Index: 0' and arr.push(6) throws 'Error Calling Method: push'

example_3.js — Nested Structure

$ Input: {"users": [{"id": 1, "name": "Alice"}], "count": 1}

› Output: {"users": [{"id": 1, "name": "Alice"}], "count": 1}

💡 Note: Nested objects and arrays are also immutable. obj.users[0].name = 'Bob' would throw 'Error Modifying: name', and obj.users.pop() would throw 'Error Calling Method: pop'

Visualization

Tap to expand

Understanding the Visualization

Wrap with Protection

Original object gets wrapped with a Proxy 'security system'

Monitor Access

All interactions are monitored by the Proxy handlers

Allow Observations

Reading properties and accessing data is permitted

Block Modifications

Any attempt to modify triggers specific error messages

Key Takeaway

🎯 Key Insight: JavaScript Proxies act as a transparent security layer that intercepts all operations, making it possible to create truly immutable objects with custom error handling while maintaining the original API.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Where n is the total number of properties/elements, as we traverse once to create proxies

✓ Linear Growth

Space Complexity

O(n)

Creates proxy wrappers for each object/array in the structure

⚡ Linearithmic Space

Constraints

The input is guaranteed to be a valid JSON object or array
Nested depth can be up to 100 levels
Object keys are strings following JSON specification
Array indices are non-negative integers
Must throw string literals, not Error objects
Only these array methods should be blocked: ['pop', 'push', 'shift', 'unshift', 'splice', 'sort', 'reverse']

Asked in

f Meta 45 G Google 38 a Amazon 32 N Netflix 28 🏠 Airbnb 25

The optimal solution uses JavaScript Proxies to create an immutable wrapper around objects and arrays. The Proxy intercepts all operations, allowing read access but blocking modifications with custom error messages. This approach handles nested structures recursively and distinguishes between object property modifications, array index changes, and mutating method calls.

Common Approaches

Approach	Time	Space	Notes
✓ Object.freeze() Approach	O(n)	O(d)	Use Object.freeze() recursively but lacks custom error messages
Proxy-Based Immutable Wrapper (Optimal)	O(n)	O(n)	Use JavaScript Proxies to intercept all operations and throw custom errors

Object.freeze() Approach — Algorithm Steps

Recursively traverse the object/array
Apply Object.freeze() to each level
Handle nested objects and arrays
Note: Cannot customize error messages

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with Root

Apply Object.freeze() to the root object

Traverse Properties

Iterate through all properties and nested objects

Recursive Freeze

Apply freeze to each nested object/array

Code -

solution.c — C

// C doesn't have built-in object/JSON support
// This is a simplified conceptual implementation
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    char* data;
    int readonly;
} ImmutableObject;

ImmutableObject* makeImmutable(const char* json_str) {
    ImmutableObject* obj = malloc(sizeof(ImmutableObject));
    obj->data = strdup(json_str);
    obj->readonly = 1; // Mark as read-only
    return obj;
}

int main() {
    const char* input = "{\"a\": 1}";
    ImmutableObject* immutable = makeImmutable(input);
    printf("%s\n", immutable->data);
    free(immutable->data);
    free(immutable);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Where n is the total number of properties/elements in the nested structure

✓ Linear Growth

Space Complexity

O(d)

Where d is the maximum depth of nesting for recursive calls

✓ Linear Space

Constraints

The input is guaranteed to be a valid JSON object or array
Nested depth can be up to 100 levels
Object keys are strings following JSON specification
Array indices are non-negative integers
Must throw string literals, not Error objects
Only these array methods should be blocked: ['pop', 'push', 'shift', 'unshift', 'splice', 'sort', 'reverse']

42.4K Views

Medium Frequency

~25 min Avg. Time

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

Object.freeze() Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler