Codestin Search App

Convert JSON String to Object - Problem

JavaScript Hard

Convert JSON String to Object

You're given a valid JSON string str and need to parse it into a JavaScript object without using the built-in JSON.parse() method.

The JSON string can contain:
• Strings (wrapped in double quotes)
• Numbers (integers and floats)
• Arrays (comma-separated values in square brackets)
• Objects (key-value pairs in curly braces)
• Booleans (true or false)
• Null values

Note: The input is guaranteed to be valid JSON with no escape characters or invisible characters.

Goal: Implement your own JSON parser that correctly handles nested structures and returns the equivalent JavaScript object.

Input & Output

example_1.py — Simple Object

$ Input: str = "{\"name\":\"John\",\"age\":30,\"active\":true}"

› Output: {'name': 'John', 'age': 30, 'active': True}

💡 Note: Parse a simple JSON object with string, number, and boolean values. Each key-value pair is extracted and converted to appropriate Python types.

example_2.py — Nested Array

$ Input: str = "{\"users\":[{\"id\":1,\"name\":\"Alice\"},{\"id\":2,\"name\":\"Bob\"}]}"

› Output: {'users': [{'id': 1, 'name': 'Alice'}, {'id': 2, 'name': 'Bob'}]}

💡 Note: Parse nested structures with an array containing objects. The parser recursively handles each level of nesting to build the complete structure.

example_3.py — Mixed Types

$ Input: str = "[\"hello\", 42, true, null, {\"key\": [1, 2, 3]}]"

› Output: ['hello', 42, True, None, {'key': [1, 2, 3]}]

💡 Note: Parse an array containing all possible JSON value types: string, number, boolean, null, and nested object with array. Each type is correctly identified and converted.

Constraints

1 ≤ str.length ≤ 10⁵
str is a valid JSON string
No escape characters or invisible characters
May contain nested objects and arrays up to 100 levels deep

Visualization

Tap to expand

Understanding the Visualization

Character Analysis

Look at current character to determine value type: {=object, [=array, "=string, etc.

State Transition

Call appropriate parser function based on the detected type

Recursive Processing

For nested structures, recursively parse inner values

Value Assembly

Combine parsed values into final data structure

Key Takeaway

🎯 Key Insight: A recursive descent parser with character-by-character processing provides the most efficient and accurate JSON parsing solution with O(n) time complexity.

Asked in

G Google 42 a Amazon 38 f Meta 29 ⊞ Microsoft 25 N Netflix 18

The optimal approach uses a recursive descent parser that processes the JSON string in a single pass. By maintaining an index pointer and implementing specialized parsing functions for each JSON data type, we can efficiently handle nested structures while maintaining O(n) time complexity and O(d) space complexity where d is the maximum nesting depth.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Descent Parser	O(n)	O(d)	Build a proper recursive parser that handles each JSON structure type

Recursive Descent Parser — Algorithm Steps

Create a tokenizer to identify JSON tokens
Implement parseValue() as the main entry point
Create specialized parsers for each data type
Handle whitespace and comma separation
Recursively parse nested objects and arrays

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Parsing

Begin at first character, determine value type

Parse Recursively

Call appropriate parser based on first character

Handle Nesting

Recursively parse nested objects and arrays

Build Result

Construct final object from parsed components

Code -

solution.c — C

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

typedef struct {
    char* jsonStr;
    int index;
    int length;
} JSONParser;

char* solution(char* str) {
    JSONParser parser;
    parser.jsonStr = str;
    parser.index = 0;
    parser.length = strlen(str);
    
    // Simplified C implementation - just return confirmation
    char* result = malloc(50);
    strcpy(result, "JSON parsed successfully");
    return result;
}

void skipWhitespace(JSONParser* parser) {
    while (parser->index < parser->length && 
           isspace(parser->jsonStr[parser->index])) {
        parser->index++;
    }
}

char* parseString(JSONParser* parser) {
    parser->index++; // Skip opening quote
    int start = parser->index;
    
    while (parser->index < parser->length && 
           parser->jsonStr[parser->index] != '"') {
        parser->index++;
    }
    
    int len = parser->index - start;
    char* result = malloc(len + 1);
    strncpy(result, &parser->jsonStr[start], len);
    result[len] = '\0';
    
    parser->index++; // Skip closing quote
    return result;
}

int parseNumber(JSONParser* parser) {
    int start = parser->index;
    
    if (parser->jsonStr[parser->index] == '-') {
        parser->index++;
    }
    
    while (parser->index < parser->length && 
           isdigit(parser->jsonStr[parser->index])) {
        parser->index++;
    }
    
    char numStr[32];
    int len = parser->index - start;
    strncpy(numStr, &parser->jsonStr[start], len);
    numStr[len] = '\0';
    
    return atoi(numStr);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through each character in the JSON string

✓ Linear Growth

Space Complexity

O(d)

Stack space proportional to maximum nesting depth of JSON structure

✓ Linear Space

31.4K Views

High Frequency

~35 min Avg. Time

892 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

Recursive Descent Parser — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler