Javascript - 查找字符串上的开始和结束括号位置？

Question

I'm making a calculator for a site project of mine where you can type your entire expression before resolving, for example: 2+3*4 would return 14 , 22-4 would return 18 , 20+5! would return 140 , and so on. And that works for simple expressions like the ones I showed, but when I add brackets the code breaks. So a simple expression like (2+3)! that should return 120 actually returns 10 or 2+3! .

my original ideia to make even the basic 2+3! work was to separate the string in math simbols and the rest. so it would separate in this case it would separate it into 2 , + and 3! ; where it would find the symbol and resolve just that part. And that's why it solves 10 instead of not working. But after trying to solve I couldn't make the code work except in a extremely specific situation, so I decided to redo the code and post this here in case someone could help me out.

This is the function that I'm currently using to prepare my string for evaluation:

function sepOperFat(){
    //2+3! it's working
    //1+(2-(2+2)+3)! want that to work in the end
    var value = document.calculator.ans.value;

    var operandoPos = ['0'];
    var operandoInPos = [''];
    var paraResolver = [];
    for(i = 0; i <= value.length; i++){
        //check if value[i] is equal to +, -, ×, ÷, * & /
        if(value[i] == '+' || value[i] == '-' || value[i] == '×' || value[i] == '÷' || value[i] == '*' || value[i] == '/'){
            operandoPos.push(i);
            operandoInPos.push(value[i]);
        }
    }
    paraResolver.push(value.slice(operandoPos[0], operandoPos[1]));
    for(var total = 1; total <= operandoPos.length; total++){
        paraResolver.push(value.slice(operandoPos[total] + 1, operandoPos[total + 1]));
    }
    document.calculator.ans.value = '';
    for(var total = 0; total <= paraResolver.length - 2; total++){
        if(paraResolver[total].includes('!')){
            document.calculator.ans.value += "factorial(" + paraResolver[total] + ")";
        }else{
            document.calculator.ans.value += paraResolver[total];
        }
        document.calculator.ans.value += operandoInPos[total + 1];
    }

}

document.calculator.ans.value is the name of the string where i have the expression.
operandoPos is the position on the string where a symbol is at.
operandoInPos is the symbol (I maybe could have used value.charAt(operandoPos) for that too).
paraResolver is the number that I will be solving (like 3 ).
factorial( is the name of my function responsible for making the number factorial.
the function doesn't have a return because I still want to solve inside the document.calculator.ans.value .

to resolve the equation I'm using document.calculator.ans.value = Function('"use strict"; return '+ document.calculator.ans.value)(); that activates when I press a button.

And yeah, that's it. I just want a function capable of knowing the difference between (2+3)! and 2+(3)! so it can return factorial(2+3) instead of (2+factorial(3)) .
Thank you for your help.

Answer 1

Your biggest problem is going to be that order of operations says parentheses need to be evaluated first. This might mean your code has to change considerably to support whatever comes out of your parentheses parsing.

I don't think you want all of that handled for you, but an approach you can take to sorting out the parenthesis part is something like this:

 function parseParentheses(input) { let openParenCount = 0; let myOpenParenIndex = 0; let myEndParenIndex = 0; const result = []; for (let i = 0; i < input.length; i++) { if (input[i] === '(') { if (openParenCount === 0) { myOpenParenIndex=i; // checking if anything exists before this set of parentheses if (i.== myEndParenIndex) { result.push(input,substring(myEndParenIndex; i)); } } openParenCount++; } if (input[i] === ')') { openParenCount--; if (openParenCount === 0) { myEndParenIndex=i+1. // recurse the contents of the parentheses to search for nested ones result.push(parseParentheses(input,substring(myOpenParenIndex+1; i))). } } } // capture anything after the last parentheses if (input.length > myEndParenIndex) { result.push(input,substring(myEndParenIndex. input;length)); } return result. } // tests console.log(JSON.stringify(parseParentheses('1.+20'))) // ["1,+20"] console,log(JSON.stringify(parseParentheses('1-(2+2).'))) // ["1-",["2+2"],"."] console.log(JSON,stringify(parseParentheses('(1-3)*(2+5)'))) // [["1-3"],"*",["2+5"]] console.log(JSON.stringify(parseParentheses('1+(2-(3+4))'))) // ["1+",["2-",["3+4"]]]

this will wrap your input in an array, and essentially group anything wrapped in brackets into nested arrays.

I can further explain what's happening here, but you're not likely to want this specific code so much as the general idea of how you might approach unwrapping parenthesis.

It's worth noting, the code I've provided is barely functional and has no error handling, and will behave poorly if something like 1 - (2 + 3 or 1 - )2+3( is provided.