Parsing and Updating Nested Objects in JavaScript

Introduction

In today's session, we’re diving into a practical task that involves working with strings to create and manipulate nested JavaScript objects. Such tasks are common in many real-world applications, where parsing and updating data structures dynamically is crucial. We'll learn how to transform a complex string into a nested JavaScript object and then update specific values within it. By the end of this lesson, you'll have a solid understanding of string parsing and nested object manipulation in JavaScript.

Task Statement

We need to transform a given complex string into a nested JavaScript object and update a specific key-value pair within that object. The input string will be in the format "Key1=Value1,Key2=Value2,..." . If the value part of a key-value pair contains another key-value string, it should be represented as a nested object. For example, the input string "A1=B1,C1={D1=E1,F1=G1},I1=J1" should be converted into the following nested JavaScript object: JavaScript let dictionary = {"A1": "B1", "C1": {"D1": "E1", "F1": "G1"}, "I1": "J1"}; let dictionary = {"A1": "B1", "C1": {"D1": "E1", "F1": "G1"}, "I1": "J1"}; After parsing this string into the nested object, we'll update the value of the nested key F1 from G1 to a new value, such as NewValue . The function should ultimately return the updated object.

Step Overview

To tackle this problem, we will take the following steps: Initialize Variables and Data Structures : Set up variables and data structures necessary for parsing the string and handling nested objects. Traverse Input String : Iterate through the input string character by character to identify and handle key-value pairs. Handle Nested Maps : Use a stack to manage and create nested maps dynamically while traversing through the string. Add Key-Value Pairs : Extract keys and values and add them to the appropriate map, whether outer or nested. Update Specific Key-Value : Recursively search through the nested object to locate and update the specified key-value pair.

Setting Up the Function and Variables

Let's start by setting up the function and the necessary variables: JavaScript function parseString(inputString) {const result = {}; let key = ""; // to store the current key let activeMap = result; // to dynamically switch between result and inner maps let stack = []; // stack to keep track of maps when nested let i = 0; // to iterate through the string function parseString(inputString) {const result = {}; let key = ""; // to store the current key let activeMap = result; // to dynamically switch between result and inner maps let stack = []; // stack to keep track of maps when nested let i = 0; // to iterate through the string Here, we initialize an empty object result which will hold our final nested structure. A key variable is used for storing the current key we are processing, while activeMap helps us to dynamically switch between outer and inner maps. The stack is utilized to keep track of nested maps, and i is an index for iterating through the string.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

JavaScript

let dictionary = {
    "A1": "B1",
    "C1": {
        "D1": "E1",
        "F1": "G1"
    },
    "I1": "J1"
};

JavaScript

function parseString(inputString) {
    const result = {};

    let key = ""; // to store the current key
    let activeMap = result; // to dynamically switch between result and inner maps
    let stack = []; // stack to keep track of maps when nested
    let i = 0; // to iterate through the string

JavaScript

    while (i < inputString.length) {
        if (inputString[i] === '{') {
            // Entering a nested map
            stack.push(activeMap); // Save the current map
            activeMap = {}; // Create a new inner map
            stack[stack.length - 1][key] = activeMap; // Link it to the outer map
            i++; // Skip the '{'
        } else if (inputString[i] === '}') {
            // Exiting a nested map
            activeMap = stack.pop(); // Restore the previous map
            i++; // Skip the '}'
            if (i < inputString.length && inputString[i] === ',') {
                i++; // Skip the ',' after '}'
            }
        }

    while (i < inputString.length) {
        if (inputString[i] === '{') {
            // Entering a nested map
            stack.push(activeMap); // Save the current map
            activeMap = {}; // Create a new inner map
            stack[stack.length - 1][key] = activeMap; // Link it to the outer map
            i++; // Skip the '{'
        } else if (inputString[i] === '}') {
            // Exiting a nested map
            activeMap = stack.pop(); // Restore the previous map
            i++; // Skip the '}'
            if (i < inputString.length && inputString[i] === ',') {
                i++; // Skip the ',' after '}'
            }
        }

JavaScript

        else {
            // Parsing key-value pairs inside the active map (could be outer or inner)
            let equalPos = inputString.indexOf('=', i);
            let delimiter = inputString.indexOf(',', equalPos);
            let bracePos = inputString.indexOf('}', equalPos);

            // Determine the next delimiter that ends the current key-value pair
            let endPos = Math.min(delimiter === -1 ? Infinity : delimiter, bracePos === -1 ? Infinity : bracePos);

            key = inputString.substring(i, equalPos);
            let value = inputString.substring(equalPos + 1, endPos);

            if (value.includes("{")) {
                // Set up for nested map; skip processing value now
                i = equalPos + 1;
            } else {
                // Add key-value pair to the active map
                activeMap[key] = value;
                i = endPos !== Infinity ? endPos : inputString.length; // Move to the next starting index
                if (i < inputString.length && inputString[i] === ',') {
                    i++; // Skip the comma
                }
            }
        }
    }

    return result;
}

        else {
            // Parsing key-value pairs inside the active map (could be outer or inner)
            let equalPos = inputString.indexOf('=', i);
            let delimiter = inputString.indexOf(',', equalPos);
            let bracePos = inputString.indexOf('}', equalPos);

            // Determine the next delimiter that ends the current key-value pair
            let endPos = Math.min(delimiter === -1 ? Infinity : delimiter, bracePos === -1 ? Infinity : bracePos);

            key = inputString.substring(i, equalPos);
            let value = inputString.substring(equalPos + 1, endPos);

            if (value.includes("{")) {
                // Set up for nested map; skip processing value now
                i = equalPos + 1;
            } else {
                // Add key-value pair to the active map
                activeMap[key] = value;
                i = endPos !== Infinity ? endPos : inputString.length; // Move to the next starting index
                if (i < inputString.length && inputString[i] === ',') {
                    i++; // Skip the comma
                }
            }
        }
    }

    return result;
}

JavaScript

let equalPos = inputString.indexOf('=', i); // Locate the '=' character
let delimiter = inputString.indexOf(',', equalPos); // Find the position of the next ','
let bracePos = inputString.indexOf('}', equalPos); // Find the position of the next '}'

let endPos = Math.min(delimiter === -1 ? Infinity : delimiter, bracePos === -1 ? Infinity : bracePos); // Calculate the end position

let equalPos = inputString.indexOf('=', i); // Locate the '=' character
let delimiter = inputString.indexOf(',', equalPos); // Find the position of the next ','
let bracePos = inputString.indexOf('}', equalPos); // Find the position of the next '}'

let endPos = Math.min(delimiter === -1 ? Infinity : delimiter, bracePos === -1 ? Infinity : bracePos); // Calculate the end position

JavaScript

key = inputString.substring(i, equalPos); // Extract the key
let value = inputString.substring(equalPos + 1, endPos); // Extract the value

key = inputString.substring(i, equalPos); // Extract the key
let value = inputString.substring(equalPos + 1, endPos); // Extract the value

JavaScript

if (value.includes("{")) { // Check for nested object
    i = equalPos + 1; // Skip processing current value
} else {
    activeMap[key] = value; // Add key-value pair to active map
    i = endPos !== Infinity ? endPos : inputString.length; // Move to the next starting index
    if (i < inputString.length && inputString[i] === ',') {
        i++; // Skip the comma
    }
}

if (value.includes("{")) { // Check for nested object
    i = equalPos + 1; // Skip processing current value
} else {
    activeMap[key] = value; // Add key-value pair to active map
    i = endPos !== Infinity ? endPos : inputString.length; // Move to the next starting index
    if (i < inputString.length && inputString[i] === ',') {
        i++; // Skip the comma
    }
}

JavaScript

function updateObject(obj, key, value) {
    if (obj.hasOwnProperty(key)) {
        obj[key] = value;
        return true;
    }

    for (let innerMap of Object.values(obj)) {
        if (typeof innerMap === 'object' && innerMap !== null) {
            if (updateObject(innerMap, key, value)) {
                return true;
            }
        }
    }

    return false;
}

function updateObject(obj, key, value) {
    if (obj.hasOwnProperty(key)) {
        obj[key] = value;
        return true;
    }

    for (let innerMap of Object.values(obj)) {
        if (typeof innerMap === 'object' && innerMap !== null) {
            if (updateObject(innerMap, key, value)) {
                return true;
            }
        }
    }

    return false;
}

JavaScript

function parseStringAndUpdateValue(inputString, updateKey, newValue) {
    // Parse the input string into a nested object
    let obj = parseString(inputString);
    // Update the specific key-value pair
    updateObject(obj, updateKey, newValue);
    return obj;
}

const input = "A1=B1,C1={D1=E1,F1=G1},I1=J1";
const updateKey = "F1";
const newValue = "NewValue";

const updatedObject = parseStringAndUpdateValue(input, updateKey, newValue);
console.log(updatedObject); // Output: { A1: 'B1', C1: { D1: 'E1', F1: 'NewValue' }, I1: 'J1' }

function parseStringAndUpdateValue(inputString, updateKey, newValue) {
    // Parse the input string into a nested object
    let obj = parseString(inputString);
    // Update the specific key-value pair
    updateObject(obj, updateKey, newValue);
    return obj;
}

const input = "A1=B1,C1={D1=E1,F1=G1},I1=J1";
const updateKey = "F1";
const newValue = "NewValue";

const updatedObject = parseStringAndUpdateValue(input, updateKey, newValue);
console.log(updatedObject); // Output: { A1: 'B1', C1: { D1: 'E1', F1: 'NewValue' }, I1: 'J1' }

JavaScript

    while (i < inputString.length) {
        if (inputString[i] === '{') {
            // Entering a nested map
            stack.push(activeMap); // Save the current map
            activeMap = {}; // Create a new inner map
            stack[stack.length - 1][key] = activeMap; // Link it to the outer map
            i++; // Skip the '{'
        } else if (inputString[i] === '}') {
            // Exiting a nested map
            activeMap = stack.pop(); // Restore the previous map
            i++; // Skip the '}'
            if (i < inputString.length && inputString[i] === ',') {
                i++; // Skip the ',' after '}'
            }
        }

JavaScript

        else {
            // Parsing key-value pairs inside the active map (could be outer or inner)
            let equalPos = inputString.indexOf('=', i);
            let delimiter = inputString.indexOf(',', equalPos);
            let bracePos = inputString.indexOf('}', equalPos);

            // Determine the next delimiter that ends the current key-value pair
            let endPos = Math.min(delimiter === -1 ? Infinity : delimiter, bracePos === -1 ? Infinity : bracePos);

            key = inputString.substring(i, equalPos);
            let value = inputString.substring(equalPos + 1, endPos);

            if (value.includes("{")) {
                // Set up for nested map; skip processing value now
                i = equalPos + 1;
            } else {
                // Add key-value pair to the active map
                activeMap[key] = value;
                i = endPos !== Infinity ? endPos : inputString.length; // Move to the next starting index
                if (i < inputString.length && inputString[i] === ',') {
                    i++; // Skip the comma
                }
            }
        }
    }

    return result;
}

JavaScript

let equalPos = inputString.indexOf('=', i); // Locate the '=' character
let delimiter = inputString.indexOf(',', equalPos); // Find the position of the next ','
let bracePos = inputString.indexOf('}', equalPos); // Find the position of the next '}'

let endPos = Math.min(delimiter === -1 ? Infinity : delimiter, bracePos === -1 ? Infinity : bracePos); // Calculate the end position

JavaScript

key = inputString.substring(i, equalPos); // Extract the key
let value = inputString.substring(equalPos + 1, endPos); // Extract the value

JavaScript

if (value.includes("{")) { // Check for nested object
    i = equalPos + 1; // Skip processing current value
} else {
    activeMap[key] = value; // Add key-value pair to active map
    i = endPos !== Infinity ? endPos : inputString.length; // Move to the next starting index
    if (i < inputString.length && inputString[i] === ',') {
        i++; // Skip the comma
    }
}

JavaScript

function updateObject(obj, key, value) {
    if (obj.hasOwnProperty(key)) {
        obj[key] = value;
        return true;
    }

    for (let innerMap of Object.values(obj)) {
        if (typeof innerMap === 'object' && innerMap !== null) {
            if (updateObject(innerMap, key, value)) {
                return true;
            }
        }
    }

    return false;
}

JavaScript

function parseStringAndUpdateValue(inputString, updateKey, newValue) {
    // Parse the input string into a nested object
    let obj = parseString(inputString);
    // Update the specific key-value pair
    updateObject(obj, updateKey, newValue);
    return obj;
}

const input = "A1=B1,C1={D1=E1,F1=G1},I1=J1";
const updateKey = "F1";
const newValue = "NewValue";

const updatedObject = parseStringAndUpdateValue(input, updateKey, newValue);
console.log(updatedObject); // Output: { A1: 'B1', C1: { D1: 'E1', F1: 'NewValue' }, I1: 'J1' }

Introduction

Task Statement

Step Overview

Setting Up the Function and Variables

Join the 1M+ learners on CodeSignal

Handling the Opening and Closing Braces

Parsing Key-Value Pairs

Parsing Summary

Updating the Value in the Object

Putting It All Together

Lesson Summary