Convert Object to JSON String - Practice Coding Problems

Convert Object to JSON String - Problem

JavaScript Medium

Convert Object to JSON String

In this challenge, you need to implement your own JSON serializer! Given any JavaScript value (string, number, array, object, boolean, or null), you must return a valid JSON string representation of that value.

The goal is to understand how JSON serialization works under the hood by building it from scratch. Your output should be a properly formatted JSON string with:

• No extra spaces - keep it compact
• Proper escaping - handle special characters in strings
• Consistent key ordering - use the same order as Object.keys()
• Correct type handling - numbers, booleans, null, strings, arrays, and objects

This is essentially building your own JSON.stringify() method! You'll gain deep insights into how modern browsers and Node.js handle JSON serialization.

Note: You cannot use the built-in JSON.stringify() method.

Input & Output

example_1.py — Simple Object

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

› Output: "{\"name\":\"Alice\",\"age\":30}"

💡 Note: Object with string and number values. Keys are quoted, strings are escaped, and numbers are converted directly. No extra spaces.

example_2.py — Array with Mixed Types

$ Input: [1, true, null, "hello"]

› Output: "[1,true,null,\"hello\"]"

💡 Note: Array containing different types: number (1), boolean (true), null, and string. Each type is serialized according to JSON rules.

example_3.py — Nested Structure

$ Input: {"users": [{"id": 1, "active": false}], "count": 1}

› Output: "{\"users\":[{\"id\":1,\"active\":false}],\"count\":1}"

💡 Note: Complex nested structure with object containing array of objects. Demonstrates recursive serialization maintaining proper JSON format.

Visualization

Tap to expand

Understanding the Visualization

Input Analysis

Examine the input value and determine its JavaScript type

Type Routing

Route to appropriate conversion logic based on the detected type

Primitive Conversion

For primitives (null, boolean, number), convert directly to string

String Escaping

For strings, add quotes and escape special characters

Recursive Processing

For arrays/objects, recursively process each element/property

Structure Assembly

Combine processed parts with appropriate delimiters and brackets

Key Takeaway

🎯 Key Insight: JSON serialization is naturally recursive - each type has specific rules, and complex structures (arrays/objects) simply apply the same rules to their contents, making the solution both elegant and efficient.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Where n is the total number of values in the structure. Each value is visited exactly once.

✓ Linear Growth

Space Complexity

O(d)

Where d is the maximum depth of nesting due to recursive call stack. Additionally, temporary arrays for join operations.

✓ Linear Space

Constraints

The input can be any valid JavaScript value
Strings may contain special characters that need escaping (\, ", \n, \r, \t)
Objects can have up to 10³ properties
Arrays can have up to 10³ elements
Maximum nesting depth is 100 levels
Cannot use JSON.stringify() or similar built-in methods
Must maintain the same key ordering as Object.keys()
Output must be valid JSON with no extra whitespace

Asked in

G Google 45 f Meta 38 a Amazon 32 N Netflix 28 ⊞ Microsoft 22

The optimal solution uses a recursive type dispatch pattern that elegantly handles all JavaScript types. The key insight is using efficient type detection (typeof + Array.isArray + null check) combined with native array joining instead of string concatenation. This approach leverages JavaScript's natural type system and functional programming patterns like map and join to create clean, maintainable code that performs optimally.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Type Dispatch (Optimal)	O(n)	O(d)	Use elegant recursive approach with optimized type detection and string building
Type Checking with String Concatenation	O(n)	O(d)	Check value type and manually build JSON string with concatenation

Recursive Type Dispatch (Optimal) — Algorithm Steps

Create a single stringify function that handles all types
Use optimized type detection (typeof + Array.isArray + null check)
Handle primitive types (null, boolean, number, string) directly
For strings, use efficient character escaping with replace chains
For arrays, map each element through recursive stringify
For objects, use Object.keys() to maintain consistent ordering
Join array elements and object pairs efficiently

Visualization

Tap to expand

Step-by-Step Walkthrough

Single Entry Point

One stringify function handles all types through pattern matching

Fast Type Detection

Efficient type checking: null check → typeof → Array.isArray

Primitive Handling

Direct conversion for null, boolean, number, and string types

Recursive Processing

Arrays and objects recursively call stringify on their contents

Efficient Joining

Use native join operations instead of manual concatenation

Code -

solution.c — C

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

typedef enum {
    JSON_NULL, JSON_BOOL, JSON_NUMBER, JSON_STRING, JSON_ARRAY, JSON_OBJECT
} json_type_t;

typedef struct json_value json_value_t;
struct json_value {
    json_type_t type;
    union {
        bool bool_val;
        double num_val;
        char* str_val;
        struct { json_value_t** items; size_t count; } array;
        struct { char** keys; json_value_t** values; size_t count; } object;
    };
};

char* escape_string(const char* str) {
    size_t len = strlen(str);
    size_t capacity = len * 2 + 3;
    char* result = malloc(capacity);
    char* p = result;
    
    *p++ = '"';
    for (const char* s = str; *s; s++) {
        switch (*s) {
            case '\\': *p++ = '\\'; *p++ = '\\'; break;
            case '"':  *p++ = '\\'; *p++ = '"'; break;
            case '\n': *p++ = '\\'; *p++ = 'n'; break;
            case '\r': *p++ = '\\'; *p++ = 'r'; break;
            case '\t': *p++ = '\\'; *p++ = 't'; break;
            default:   *p++ = *s; break;
        }
    }
    *p++ = '"';
    *p = '\0';
    
    return result;
}

char* stringify(const json_value_t* val) {
    switch (val->type) {
        case JSON_NULL: {
            char* result = malloc(5);
            strcpy(result, "null");
            return result;
        }
        case JSON_BOOL: {
            const char* str = val->bool_val ? "true" : "false";
            char* result = malloc(strlen(str) + 1);
            strcpy(result, str);
            return result;
        }
        case JSON_NUMBER: {
            char* result = malloc(32);
            snprintf(result, 32, "%.15g", val->num_val);
            return result;
        }
        case JSON_STRING: {
            return escape_string(val->str_val);
        }
        case JSON_ARRAY: {
            // Calculate total size needed
            size_t total_size = 2; // for [ ]
            char** element_strs = malloc(val->array.count * sizeof(char*));
            
            for (size_t i = 0; i < val->array.count; i++) {
                element_strs[i] = stringify(val->array.items[i]);
                total_size += strlen(element_strs[i]);
                if (i > 0) total_size++; // for comma
            }
            
            char* result = malloc(total_size + 1);
            char* p = result;
            *p++ = '[';
            
            for (size_t i = 0; i < val->array.count; i++) {
                if (i > 0) *p++ = ',';
                strcpy(p, element_strs[i]);
                p += strlen(element_strs[i]);
                free(element_strs[i]);
            }
            
            *p++ = ']';
            *p = '\0';
            free(element_strs);
            return result;
        }
        case JSON_OBJECT: {
            size_t total_size = 2; // for { }
            char** key_strs = malloc(val->object.count * sizeof(char*));
            char** val_strs = malloc(val->object.count * sizeof(char*));
            
            for (size_t i = 0; i < val->object.count; i++) {
                key_strs[i] = escape_string(val->object.keys[i]);
                val_strs[i] = stringify(val->object.values[i]);
                total_size += strlen(key_strs[i]) + strlen(val_strs[i]) + 1; // +1 for :
                if (i > 0) total_size++; // for comma
            }
            
            char* result = malloc(total_size + 1);
            char* p = result;
            *p++ = '{';
            
            for (size_t i = 0; i < val->object.count; i++) {
                if (i > 0) *p++ = ',';
                strcpy(p, key_strs[i]);
                p += strlen(key_strs[i]);
                *p++ = ':';
                strcpy(p, val_strs[i]);
                p += strlen(val_strs[i]);
                free(key_strs[i]);
                free(val_strs[i]);
            }
            
            *p++ = '}';
            *p = '\0';
            free(key_strs);
            free(val_strs);
            return result;
        }
    }
    return NULL;
}

char* solution(const json_value_t* value) {
    return stringify(value);
}

int main() {
    json_value_t test = {
        .type = JSON_STRING,
        .str_val = "Hello, World!"
    };
    
    char* result = solution(&test);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Where n is the total number of values in the structure. Each value is visited exactly once.

✓ Linear Growth

Space Complexity

O(d)

Where d is the maximum depth of nesting due to recursive call stack. Additionally, temporary arrays for join operations.

✓ Linear Space

Constraints

The input can be any valid JavaScript value
Strings may contain special characters that need escaping (\, ", \n, \r, \t)
Objects can have up to 10³ properties
Arrays can have up to 10³ elements
Maximum nesting depth is 100 levels
Cannot use JSON.stringify() or similar built-in methods
Must maintain the same key ordering as Object.keys()
Output must be valid JSON with no extra whitespace

82.6K Views

High 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

Recursive Type Dispatch (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler