Javascript 如何解析不同嵌套深度的JSON，然后执行基本计算？

我对JS非常陌生，正在尝试使用一个基本的计算器来读取JSON字符串并对其执行基本的“加”或“减”操作。目前，它可以处理1级深字符串，如下所示：

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

其中初始值为0，将执行0+15，因此输出为15。我现在要做的是使同一个函数处理一个嵌套字符串，如“expr”表示嵌套表达式的开始：

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

操作应该是这样的：（0-3=-3，-3+-3=-6，-6+-6=-12）

我目前的计划如下：

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));

---

我如何修改它以进一步处理3、4、5级嵌套字符串？

嘿，好了，我希望这有帮助

我将在while循环中使用递归来查找根的位置，并在嵌套数组中移动时捕获所有操作。之后，我将使用for循环来整合答案

string={“op”：“add”，“expr”：{“op”：“add”，“expr”：{“op”：“subtract”，“number”：3}}；
var计数=0；
var运算=[]；
//查找数字的位置并记录到目前为止的所有操作
while（string.number==未定义）{
操作[count]=string.op；
string=string.expr
计数++；
}
var num=0；//起始数
操作.push（string.op）；//加法运算
number=string.number//这是我们需要处理的num
//现在我们只需要反向工作
对于（变量i=0；iconsole.log（num）如果您的表达式将始终保持您发布的表单，那么这应该有效

也许在这种情况下，递归方法更容易理解

class Calc {

    evaluate(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.evaluate(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.evaluate(expression.expr);
                    this.num -= temp;
                }
            }
        }
        return this.num;
    }

    calc(str) {
        let object = JSON.parse(str);
        this.num = 0;
        return this.evaluate(object);
    }
}

foo = '{"op": "add", "number": 15}';
bar = '{"op": "add", "expr" : {"op" : "add", "expr" : {"op" : "subtract", "number" : 3}}}';

c = new Calc();
c.calc(foo);
c.calc(bar);

我相信你们可以用递归来解决这个问题。希望能有帮助


let exp = '{"op": "add", "expr" : {"op" : "add", "expr" : {"op" : "subtract", "number" : 3}}}';
const addNumber = 'add';
const subtractNumber = 'subtract';

class Calculator {
    calculate(str){

    let object = JSON.parse(str);
    let prevSum = 0;

        function traverseObject(object){

            if(object == undefined){
                return 0;
            }
            let temp = traverseObject(object.expr);
            if(object.hasOwnProperty('number') == true){
                prevSum = object['number'];
            }
            if(object.op == addNumber){
                prevSum += temp;
            }
            if(object.op == subtractNumber){
                prevSum -= temp;
            }
            return prevSum;

        }
        return traverseObject(object);
        }
}

使用递归。还要注意，您发布的第一个字符串不是有效的JSON。还有，为什么要使用一个类，它有一个方法，不引用
this
，而是修改一个全局变量？只是让它成为一个函数。它怎么会无效，它处理的很好。为了满足需求，我需要在它自己的类中使用它。另外，我应该为递归传递什么？嗯…
{op:'add'，number:15}'
不是有效的JSON。它甚至不是一个有效的Javascript字符串（因此，它的语法突出显示应该向您提示这一点）。如果将其中一组单引号替换为双引号以修复此问题，则将其提供给JSON解析将抛出错误，因为属性名和字符串不是双引号。如果这听起来像是我吹毛求疵，那是因为我吹毛求疵，而我吹毛求疵是因为电脑很吹毛求疵