Javascript Array.indexOf或介于两者之间？

我目前正在设计一个GUI，允许用户定义一些逻辑。我不希望它变得太复杂，所以我把它限制在一组括号内。因此，我们的想法是检查在开始和结束括号之间没有任何其他开始括号

例如，

如果（a+b或**（**b+c）

将发出错误警报

因此，我决定采取以下路线：

• 找到第一个打开的括号
• 找到第一个紧括号
• 使用这些索引搜索并找到任何开括号
• 如果发现任何打开的括号，则显示错误
• 对于任何其他逻辑，继续循环

这是代码。我认为它非常可怕，我相信一定有更好的方法来做到这一点。也许是某种索引

<select rel="OpenBracket" id="open1">
    <option value=""></option>
    <option value="(">(</option>
</select>
Some True/Fale here
<select rel="CloseBracket" id="close1">
    <option value=""></option>
    <option value=")">)</option>
</select>
AND
<br />
<select rel="OpenBracket" id="open2">
    <option value=""></option>
    <option value="(">(</option>
</select>
Some True/Fale here
<select rel="CloseBracket" id="close2">
    <option value=""></option>
    <option value=")">)</option>
</select>
<button onclick="javascript:TestingRules();">Check</button>

(
这里有些对/错
)
及


(
这里有些对/错
)
检查

---

函数getOpen括号（）{ var openBracketArray=[]； jQuery（'[rel=“OpenBracket”]'）。每个（函数（）{ if（jQuery（this）.val（）=“（”）{ openBracketArray.push（jQuery（this.attr（'id'））； }否则{ push（jQuery（this.val（））； } }); 返回openBracketArray； } 函数getCloseBrands（）{ var closeBracketArray=[]； jQuery（'[rel=“CloseBracket”]'）。每个（函数（）{ if（jQuery（this）.val（）=“（”）{ closeBracketArray.push（jQuery（this.attr（'id'））； }否则{ closeBracketArray.push（jQuery（this.val（））； } }); 返回近间隔排列； } 函数测试规则（）{ var open括号=getopen括号（）； var closebrands=getclosebrands（）； var闭括号指数； var开放括号指数； for（openBracketIndex在openBrackets中）{ 如果（openBracketIndex]！=“”）{ var foundCloseBracketIndex=-1； for（closeBracketIndex在closeBrackets中）{ 如果（openBracketIndex-1）{ var openBracketCheck； 对于（OpenBracket在openBrackets中选中）{ 如果（openBracketIndex=openBracketCheck）{ 如果（OpenBracks[OpenBrackCheck]！=“”）{ 警报（“错误”）； } } } } } } //对于测试： //控制台.log（OpenBracketArray.length）； }

---

为什么不保留一个计数器，或者计算paren堆栈深度？如果您inc表示打开paren，dec表示关闭，并且计数器超过1，那么您有一个错误。（如果我正确理解了您的要求。）

我相信您可以尝试实现

概念上的

堆栈（top=0）

和

每当看到
（
和

[（可选）如果top>X，其中X是允许的深度，则错误输出无效的表达式长度]

pop（top=top-1）
只要你看到
）

当表达式完成时，堆栈（顶部>0）上仍有剩余内容

您可以推断表达式是不平衡的。

与其尝试查找一对括号，为什么不搜索一行中的两个开放括号？当您找到第一个开放括号时，有两件事是可能的：要么后面的内容用封闭括号括起来（因此用户没有嵌套它们），或者您找到另一个开括号。如果您找到另一个开括号，则用户正在尝试嵌套语句。这样可以避免您再次返回并搜索同一空间。

堆栈是正确的方法，但他不希望嵌套深度大于X的括号，因此答案还应提及堆栈中不能有更多的一次在其上放置一个X项这更简单，适用于1个或更多。因此，如果解决方案足够简单，为什么不使用它。没错，我只是说，如果OP有理由不超过1层深度，那么答案应该反映出来，将立即检查并让您知道：）.对JS不太熟悉，所以堆栈、推送和弹出的东西对我来说是新的。我会继续研究，然后再深入研究。谢谢你的回答，因为这是用我最少的JS知识最容易实现的答案。这篇文章可能非常有效，但我没有像另一篇那么容易理解（即使是研究）。将此作为答案，因为这是用我最少的JS知识最容易实现的。另一篇文章可能非常有效，但我没有像这篇文章那么容易理解。此外，这是一个非常简单的解决方案。@Piercy它基本上与堆栈相同，至少在计算paren方面。堆栈还允许表达式ev计算——这是一个更通用的解决方案。区别在于inc/dec/数值比较与push/pop/堆栈大小比较。

function GetOpenBrackets() {
    var openBracketArray = [];
    jQuery('[rel="OpenBracket"]').each(function() {
        if (jQuery(this).val() == "(") {
            openBracketArray.push(jQuery(this).attr('id'));
        } else {
            openBracketArray.push(jQuery(this).val());
        }

    });
    return openBracketArray;
}

function GetCloseBrackets() {
    var closeBracketArray = [];
    jQuery('[rel="CloseBracket"]').each(function() {
        if (jQuery(this).val() == "(") {
            closeBracketArray.push(jQuery(this).attr('id'));
        } else {
            closeBracketArray.push(jQuery(this).val());
        }
    });
    return closeBracketArray;
}
function TestingRules() {
    var openBrackets = GetOpenBrackets();
    var closeBrackets = GetCloseBrackets();
    var closeBracketIndex;
    var openBracketIndex;
    for (openBracketIndex in openBrackets) {
        if (openBrackets[openBracketIndex] !== "") {

            var foundCloseBracketIndex = -1;
            for (closeBracketIndex in closeBrackets) {
                if (openBracketIndex <= closeBracketIndex) {
                    if (closeBrackets[closeBracketIndex] !== "") {
                        foundCloseBracketIndex = closeBracketIndex;
                        break;
                    }
                }
            }
            if (foundCloseBracketIndex > -1) {
            var openBracketCheck;
                for (openBracketCheck in openBrackets) {

                    if (openBracketIndex < openBracketCheck && closeBracketIndex >= openBracketCheck) {
                        if (openBrackets[openBracketCheck] !== "") {
                            alert('error');
                        }
                    }

                }
            }
        }

    }

    // for testing:
    //  console.log(OpenBracketArray.length);
}