如何用原生JavaScript验证含变量的逻辑表达式字符串有效性？

要解决这个问题，核心是先明确合法表达式的语法规则，再选择合适的验证方案——递归下降解析是处理这类语法验证的标准可靠方法，也可以用正则表达式覆盖大部分常见场景。

明确合法表达式的语法规则 #

先定义无歧义的语法规则，避免验证逻辑混乱：

• 操作数：由字母（大小写）、数字组成的标识符（首字符必须是字母，比如a、B2）
• 运算符：仅&（与）、|（或），均为双目运算符，必须左右都有合法操作数
• 括号：( 和 ) 必须成对出现，且括号内部必须是完整的合法表达式
• 禁止情况：
  • 表达式以运算符开头或结尾（比如&a|b、a&b|）
  • 连续出现运算符（比如a&&b、a&|b）
  • 操作数直接紧跟括号（比如a(b&c)）
  • 括号为空或内部只有运算符（比如()、(&a)）

注：你列出的无效案例中(a&b)本身是合法的逻辑表达式，如果需要将其判定为无效，可能是额外的业务规则（比如要求表达式必须包含至少两个顶级操作数），可以在基础验证通过后添加额外判断。

方案一：递归下降解析器（严谨可靠） #

递归下降解析是处理这类结构化语法验证的标准方案，通过模拟语法规则的递归结构逐字符验证，能覆盖所有边界场景，包括你提到的(a(&b&c))这类嵌套非法子表达式的情况。

实现代码 #

function isValidLogicalExpression(expr) {
    // 去除所有空白字符（如果允许表达式带空格可保留此步）
    const cleaned = expr.replace(/\s+/g, '');
    let index = 0;

    // 解析完整表达式：表达式 = 项 ( ( & | ) 项 )*
    function parseExpression() {
        if (!parseTerm()) return false;
        // 循环处理后续的运算符+项结构
        while (index < cleaned.length && (cleaned[index] === '&' || cleaned[index] === '|')) {
            index++; // 跳过运算符
            if (!parseTerm()) return false; // 运算符后必须有合法项
        }
        return true;
    }

    // 解析单个项：项 = 标识符 | ( 表达式 )
    function parseTerm() {
        if (index >= cleaned.length) return false;
        
        // 处理括号包裹的子表达式
        if (cleaned[index] === '(') {
            index++; // 跳过左括号
            const valid = parseExpression();
            // 子表达式非法、无匹配右括号都判定无效
            if (!valid || index >= cleaned.length || cleaned[index] !== ')') {
                return false;
            }
            index++; // 跳过右括号
            return true;
        }

        // 处理标识符（字母开头，可跟字母数字）
        if (/[a-zA-Z]/.test(cleaned[index])) {
            index++;
            while (index < cleaned.length && /[a-zA-Z0-9]/.test(cleaned[index])) {
                index++;
            }
            return true;
        }

        // 既不是括号也不是标识符，判定非法
        return false;
    }

    // 解析完成后必须耗尽所有字符，避免残留非法字符
    const valid = parseExpression();
    return valid && index === cleaned.length;
}

// 测试用例验证
console.log(isValidLogicalExpression('(a&b|c)&d')); // true
console.log(isValidLogicalExpression('a&(b|c)')); // true
console.log(isValidLogicalExpression('(a&b)|(c&d)')); // true
console.log(isValidLogicalExpression('a(b&c)')); // false
console.log(isValidLogicalExpression('a(&b|c)')); // false
console.log(isValidLogicalExpression('(a(&b&c))')); // false

代码说明 #

• parseExpression：负责验证完整表达式的结构，确保每个运算符左右都有合法操作数
• parseTerm：负责验证单个操作数，支持标识符和括号包裹的子表达式
• 最终检查是否耗尽所有字符，避免出现a&b(c)这类末尾残留非法字符的情况

方案二：正则表达式（适合简单场景） #

如果场景不需要支持复杂的标识符规则或深层嵌套，也可以用正则表达式结合括号平衡检查来验证，实现更简洁，但对极端嵌套场景的兼容性略差。

实现代码 #

function isValidLogicalExpressionRegex(expr) {
    const cleaned = expr.replace(/\s+/g, '');
    
    // 先检查括号平衡
    let balance = 0;
    for (const char of cleaned) {
        if (char === '(') balance++;
        else if (char === ')') balance--;
        if (balance < 0) return false;
    }
    if (balance !== 0) return false;

    // 递归正则匹配合法结构：允许标识符或括号包裹的合法表达式，通过&/|连接
    // 注：(?R)是递归匹配语法，Chrome、Node.js等现代JS环境支持
    const regex = /^(?:([a-zA-Z][a-zA-Z0-9]*|\((?:[^()]|(?R))*\))([&|]([a-zA-Z][a-zA-Z0-9]*|\((?:[^()]|(?R))*\)))*)$/;
    return regex.test(cleaned);
}

// 测试用例验证
console.log(isValidLogicalExpressionRegex('(a&b|c)&d')); // true
console.log(isValidLogicalExpressionRegex('a&(b|c)')); // true
console.log(isValidLogicalExpressionRegex('(a&b)|(c&d)')); // true
console.log(isValidLogicalExpressionRegex('a(b&c)')); // false
console.log(isValidLogicalExpressionRegex('a(&b|c)')); // false
console.log(isValidLogicalExpressionRegex('(a(&b&c))')); // false

注意事项 #

• 递归正则的(?R)语法在部分旧JS环境中不兼容，若需兼容可手动展开嵌套逻辑，但会增加正则复杂度
• 正则方案对于极端复杂的多层嵌套场景，可靠性不如递归下降解析器

内容的提问来源于stack exchange，提问作者jwz