如何在JavaScript中验证含嵌套括号的合法字符串并转换为JSON

核心思路：递归解析+栈校验 #

字符拆分法无法处理嵌套括号的层级关系，必须用栈结构做括号合法性校验，配合递归解析函数结构来处理多层嵌套逻辑。

一、合法性判定示例 #

合法字符串 #

• AND(TRUE, FALSE, SUM(1,2,3)>5)
• OR(SUM(MAX(4,6), MIN(2,3)), 10>20, AND(TRUE, FALSE))
• SUM(1, 2, AVG(3,4,5), 6)

非法字符串 #

• AND(TRUE, FALSE （括号未闭合）
• OR(, TRUE) （存在空占位参数）
• SUM(1, 2) 3 （函数后附带无意义字符）
• INVALID_FUNC(1,2) （使用未定义函数，若有函数白名单则判定非法）

二、实现步骤 #

1. 括号合法性校验 #

用栈跟踪括号的匹配状态，确保嵌套结构正确：

def validate_parentheses(s):
    stack = []
    for c in s:
        if c == '(':
            stack.append(c)
        elif c == ')':
            if not stack:
                return False
            stack.pop()
    return len(stack) == 0

2. 递归解析函数结构 #

将合法字符串转换为指定JSON结构，以下是预期结构示例（以AND(TRUE, SUM(1,2)>3)为例）：

{
  "type": "function",
  "name": "AND",
  "arguments": [
    {"type": "literal", "value": true},
    {
      "type": "comparison",
      "operator": ">",
      "left": {
        "type": "function",
        "name": "SUM",
        "arguments": [
          {"type": "literal", "value": 1},
          {"type": "literal", "value": 2}
        ]
      },
      "right": {"type": "literal", "value": 3}
    }
  ]
}

核心解析代码片段：

import re
from typing import Dict, List, Union

def parse_expression(s: str) -> Union[Dict, None]:
    s = s.strip()
    # 匹配函数格式：函数名(参数列表)
    func_match = re.match(r'^([A-Z_]+)\((.*)\)$', s)
    if func_match:
        func_name = func_match.group(1)
        args_str = func_match.group(2)
        args = split_args(args_str)
        return {
            "type": "function",
            "name": func_name,
            "arguments": [parse_expression(arg) for arg in args]
        }
    # 匹配比较表达式
    comp_match = re.match(r'^(.*?)([<>!=]=?)(.*)$', s)
    if comp_match:
        left = comp_match.group(1).strip()
        op = comp_match.group(2)
        right = comp_match.group(3).strip()
        return {
            "type": "comparison",
            "operator": op,
            "left": parse_expression(left),
            "right": parse_expression(right)
        }
    # 匹配字面量（布尔、数字）
    if s == 'TRUE':
        return {"type": "literal", "value": True}
    if s == 'FALSE':
        return {"type": "literal", "value": False}
    if s.replace('.', '', 1).isdigit():
        return {"type": "literal", "value": float(s) if '.' in s else int(s)}
    # 非法表达式返回None
    return None

def split_args(args_str: str) -> List[str]:
    """拆分函数参数，处理嵌套括号"""
    args = []
    current = []
    bracket_count = 0
    for c in args_str:
        if c == ',' and bracket_count == 0:
            args.append(''.join(current).strip())
            current = []
        else:
            if c == '(':
                bracket_count +=1
            elif c == ')':
                bracket_count -=1
            current.append(c)
    if current:
        args.append(''.join(current).strip())
    return args

3. 完整验证与转换流程 #

def process_expression(s: str) -> Union[Dict, str]:
    # 先校验括号合法性
    if not validate_parentheses(s):
        return "非法：括号不匹配"
    # 解析表达式
    result = parse_expression(s)
    if not result:
        return "非法：表达式格式错误"
    return result

# 测试示例
print(process_expression("AND(TRUE, SUM(1,2)>3)"))

三、关键扩展点 #

• 函数名大小写兼容：可在匹配函数名时统一转换为大写/小写，忽略大小写差异
• 字符串字面量支持：添加对带引号字符串的匹配逻辑，扩展字面量类型
• 函数白名单校验：在解析函数时加入白名单判断，仅允许指定函数调用

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