How can I efficiently extract and process JSON data with different levels of nesting in order to conduct simple computations?

Question

How can I efficiently extract and process JSON data with different levels of nesting in order to conduct simple computations?

I'm relatively new to the world of JavaScript and I'm currently working on a basic calculator that is able to read JSON strings and execute basic "add" or "subtract" operations based on them. At the moment, it can handle 1-level deep strings such as:

'{ op: 'add', number: 15 }'

This means that starting from an initial value of 0, it performs 0 + 15 resulting in an output of 15. However, my goal now is to enhance this functionality to process nested strings like the following, where "expr" indicates the beginning of a nested expression:

'{"op": "add", "expr" : {"op" : "add", "expr" : {"op" : "subtract", "number" : 3}}}'

The computation for this nested string should unfold as follows: (0 - 3 = -3, -3 + (-3) = -6, -6 + (-6) = -12)

Here's the current structure of my program:

let num = 0;

class Calc {
  calc(str) {
    let object = JSON.parse(str);
    if (object.op === "add") {
      num += object.number;
    } else if (object.op === "subtract") {
      num -= object.number;
    }
    return num;
  }
}

let c = new Calc();
let exp = '{"op": "add", "expr" : {"op" : "add", "expr" : {"op" : "subtract", "number" : 3}}}';
// console.log(c.calc(exp));

As I progress with this project, I am contemplating how to adapt this code to support processing of even more complex, deeply nested strings spanning 3, 4, or even 5 levels.

javascript arrays json parsing

Answer 1

Answer №1

If your expressions always maintain the structure as you've shown, then this solution should work perfectly.

Perhaps this scenario is better suited for a recursive approach, which can be easier to grasp.

class Calculator {

    evaluateExpression(expression) {

        let temp = 0;
        if ('op' in expression) {
            if (expression.op == 'add') {
                if ('number' in expression) {
                    this.num += expression.number; 
                }
                else if ('expr' in expression) {
                    temp = this.evaluateExpression(expression.expr);
                    this.num += temp
                }
            }
            else if (expression.op == 'subtract') {
                if ('number' in expression) {
                    this.num -= expression.number; 
                }
                else if ('expr' in expression) {
                    temp = this.evaluateExpression(expression.expr);
                    this.num -= temp;
                }
            }
        }
        return this.num;
    }

    performCalculation(input) {
        let obj = JSON.parse(input);
        this.num = 0;
        return this.evaluateExpression(obj);
    }
}

fooInput = '{"op": "add", "number": 15}';
barInput = '{"op": "add", "expr" : {"op" : "add", "expr" : {"op" : "subtract", "number" : 3}}}';

calcInstance = new Calculator();
calcInstance.performCalculation(fooInput);
calcInstance.performCalculation(barInput);

Answer 2

If your expressions always maintain the structure as you've shown, then this solution should work perfectly.

Perhaps this scenario is better suited for a recursive approach, which can be easier to grasp.

class Calculator {

    evaluateExpression(expression) {

        let temp = 0;
        if ('op' in expression) {
            if (expression.op == 'add') {
                if ('number' in expression) {
                    this.num += expression.number; 
                }
                else if ('expr' in expression) {
                    temp = this.evaluateExpression(expression.expr);
                    this.num += temp
                }
            }
            else if (expression.op == 'subtract') {
                if ('number' in expression) {
                    this.num -= expression.number; 
                }
                else if ('expr' in expression) {
                    temp = this.evaluateExpression(expression.expr);
                    this.num -= temp;
                }
            }
        }
        return this.num;
    }

    performCalculation(input) {
        let obj = JSON.parse(input);
        this.num = 0;
        return this.evaluateExpression(obj);
    }
}

fooInput = '{"op": "add", "number": 15}';
barInput = '{"op": "add", "expr" : {"op" : "add", "expr" : {"op" : "subtract", "number" : 3}}}';

calcInstance = new Calculator();
calcInstance.performCalculation(fooInput);
calcInstance.performCalculation(barInput);

Answer 3

Answer №2

Greetings, I trust this information proves beneficial!

To identify the root within your nested array and track all operations, my approach would involve utilizing recurrence in a while loop. Subsequently, I would employ a for loop to streamline the solution.

data = {"op": "add", "expr" : {"op" : "add", "expr" : {"op" : "subtract", "number" : 3}}};

var count = 0;
var ops = [];

// Identifying the location of the number while logging each operation
while (data.number == undefined) {
    ops[count] = data.op;
    data = data.expr;
    count++;
}

var num = 0; // Initial value
ops.push(data.op); // Addition operation with the number
number = data.number; // The target number

// Retroactively computing the result
for (var i = 0; i < ops.length; i++) {

    if (ops[ops.length - i - 1] === "add") {
        num += number;
    } else if (ops[ops.length - i - 1] === "subtract") {
        num -= number;
    }

    number = num;
}

console.log(num);

Nevertheless: I recall one of my instructors advising against the use of while loops in production code... but while serves a purpose as any other tool should be properly utilized 😄

Answer 4

Greetings, I trust this information proves beneficial!

To identify the root within your nested array and track all operations, my approach would involve utilizing recurrence in a while loop. Subsequently, I would employ a for loop to streamline the solution.

data = {"op": "add", "expr" : {"op" : "add", "expr" : {"op" : "subtract", "number" : 3}}};

var count = 0;
var ops = [];

// Identifying the location of the number while logging each operation
while (data.number == undefined) {
    ops[count] = data.op;
    data = data.expr;
    count++;
}

var num = 0; // Initial value
ops.push(data.op); // Addition operation with the number
number = data.number; // The target number

// Retroactively computing the result
for (var i = 0; i < ops.length; i++) {

    if (ops[ops.length - i - 1] === "add") {
        num += number;
    } else if (ops[ops.length - i - 1] === "subtract") {
        num -= number;
    }

    number = num;
}

console.log(num);

Nevertheless: I recall one of my instructors advising against the use of while loops in production code... but while serves a purpose as any other tool should be properly utilized 😄

Answer 5

Answer №3

I think utilizing recursive methods can offer a solution to this particular issue. I hope this suggestion proves beneficial!


let expression = '{"op": "multiply", "expr" : {"op" : "multiply", "expr" : {"op" : "divide", "number" : 6}}}';
const multiplyOperation = 'multiply';
const divideOperation = 'divide';

class MathSolver {
    solveEquation(inputString){

    let objectData = JSON.parse(inputString);
    let previousResult = 0;

        function performOperation(obj){

            if(obj == undefined){
                return 0;
            }
            let temporaryValue = performOperation(obj.expr);
            if(obj.hasOwnProperty('number') == true){
                previousResult = obj['number'];
            }
            if(obj.op == multiplyOperation){
                previousResult *= temporaryValue;
            }
            if(obj.op == divideOperation){
                previousResult /= temporaryValue;
            }
            return previousResult;

        }
        return performOperation(objectData);
        }
}

Answer 6

I think utilizing recursive methods can offer a solution to this particular issue. I hope this suggestion proves beneficial!


let expression = '{"op": "multiply", "expr" : {"op" : "multiply", "expr" : {"op" : "divide", "number" : 6}}}';
const multiplyOperation = 'multiply';
const divideOperation = 'divide';

class MathSolver {
    solveEquation(inputString){

    let objectData = JSON.parse(inputString);
    let previousResult = 0;

        function performOperation(obj){

            if(obj == undefined){
                return 0;
            }
            let temporaryValue = performOperation(obj.expr);
            if(obj.hasOwnProperty('number') == true){
                previousResult = obj['number'];
            }
            if(obj.op == multiplyOperation){
                previousResult *= temporaryValue;
            }
            if(obj.op == divideOperation){
                previousResult /= temporaryValue;
            }
            return previousResult;

        }
        return performOperation(objectData);
        }
}

How can I efficiently extract and process JSON data with different levels of nesting in order to conduct simple computations?

Answer №1

Answer №2

Answer №3

Similar questions

Passing an array as an argument to a pointer in C

What is the importance of including parentheses when passing a function to a directive?

Tips for including absent items in an array

Update a div container using jQuery

Exploring the depths of asynchronous calls in AngularJS with nested functions

What information is displayed on the visible class roster?

The event is eagerly anticipating the AJAX call despite the asynchronous setting being true

Tips for keeping components mounted despite changes in the path

What are the steps to deploy Next JS?

Loop through a SimpleXMLElement array and save each element to its own text file

Incorporate a pair of additional columns and showcase the outcome within a third column within an HTML

Integrating chat functionality with a structured data format

Tips for navigating between slides on a CSS carousel?

Requesting data with Ajax: utilizing parameters in the format of x-www-form-urlencoded

Traverse a JSON array containing numerous results

Equivalent of window.onkeypress in Typescript and NodeJS

Exploring Vue Routing with Regular Expressions

Whenever I try to access my Node.js API from Heroku's live server, I encounter a CORS policy error

The responses stored within the array should remain intact and not vanish

Display more/hide less form using div elements in a NextJS project