使用Parsimonious精准解析包含空值的逗号分隔字符串数组

# 初步尝试的语法
string = ~'"[^\"]+"'
comma = ","
array = "(" (comma / string)* ")"

from parsimonious import Grammar

grammar_definition = """
  array = "(" string? (comma string?)* ")"
  string = ~'"[^\"]+"'
  comma = ","
"""
grammar = Grammar(grammar_definition)

from parsimonious import Grammar, ParseError

# 定义Parsimonious语法
grammar_definition = """
  array = "(" string? (comma string?)* ")"
  string = ~'"[^\"]+"'
  comma = ","
"""
grammar = Grammar(grammar_definition)

# 测试用例
test_cases = [
    ('("My","Cool","Array")', True),         # 标准格式，无空值
    ('("My","Cool","Array",)', True),        # 末尾带空值
    ('(,,"My","Cool",,"Array",,,)', True),   # 包含多个空值和连续空值
    ('()', True),                             # 空数组
    ('(,)', True),                            # 只有一个空值
    ('("My""Cool""Array")', False),          # 错误格式：缺少逗号分隔
    ('("OnlyOne")', True),                    # 单个元素
    ('(,"OnlyOne")', True),                   # 开头空值，一个元素
    ('("OnlyOne",)', True),                   # 一个元素，结尾空值
    ('(,"OnlyOne",)', True),                  # 开头空值，一个元素，结尾空值
    ('"NotAnArray"', False),                  # 错误格式：不是数组
    ('("MissingQuote)', False),               # 错误格式：引号不匹配
]

print("--- Parsimonious 语法解析测试 ---")
for s, expected_success in test_cases:
    try:
        grammar.parse(s)
        print(f"'{s}' -> 成功解析 (预期: {'成功' if expected_success else '失败'}) {'✅' if expected_success else '❌'}")
    except ParseError as e:
        print(f"'{s}' -> 解析失败 (预期: {'成功' if expected_success else '失败'}) {'❌' if expected_success else '✅'}")
        # print(f"  错误信息: {e}") # 可选：打印错误详情

--- Parsimonious 语法解析测试 ---
'("My","Cool","Array")' -> 成功解析 (预期: 成功) ✅
'("My","Cool","Array",)' -> 成功解析 (预期: 成功) ✅
'(,,"My","Cool",,"Array",,,)' -> 成功解析 (预期: 成功) ✅
'()' -> 成功解析 (预期: 成功) ✅
'(,)' -> 成功解析 (预期: 成功) ✅
'("My""Cool""Array")' -> 解析失败 (预期: 失败) ✅
'("OnlyOne")' -> 成功解析 (预期: 成功) ✅
'(,"OnlyOne")' -> 成功解析 (预期: 成功) ✅
'("OnlyOne",)' -> 成功解析 (预期: 成功) ✅
'(,"OnlyOne",)' -> 成功解析 (预期: 成功) ✅
'"NotAnArray"' -> 解析失败 (预期: 失败) ✅
'("MissingQuote)' -> 解析失败 (预期: 失败) ✅

from parsimonious.nodes import NodeVisitor

class ArrayVisitor(NodeVisitor):
    def visit_array(self, node, visited_children):
        # 提取括号内的内容，忽略括号本身
        elements = []
        for child in visited_children:
            if isinstance(child, list): # 处理 (comma string?)* 的列表
                for item in child:
                    if item is not None and item != ',': # 过滤掉逗号和None
                        elements.append(item)
            elif child is not None and child != '(' and child != ')':
                elements.append(child)
        return [e if e != '' else None for e in elements] # 将空字符串转换成None

    def visit_string(self, node, visited_children):
        # 移除字符串两端的引号
        return node.text[1:-1]

    def visit_comma(self, node, visited_children):
        return node.text # 返回逗号本身，后续过滤

    def generic_visit(self, node, visited_children):
        # 对于没有特定访问方法的节点，如果只有一个子节点，返回子节点；否则返回None
        if len(visited_children) == 1:
            return visited_children[0]
        return None # 默认返回None，表示该节点不贡献具体值

# 示例使用
tree = grammar.parse('(,,"My","Cool",,"Array",,,)')
result_list = ArrayVisitor().visit(tree)
print(f"\n解析树转换为列表: {result_list}")

tree_empty = grammar.parse('()')
result_empty_list = ArrayVisitor().visit(tree_empty)
print(f"空数组解析为列表: {result_empty_list}")

tree_single_empty = grammar.parse('(,)')
result_single_empty_list = ArrayVisitor().visit(tree_single_empty)
print(f"仅含一个空值的数组解析为列表: {result_single_empty_list}")

解析树转换为列表: [None, None, 'My', 'Cool', None, 'Array', None, None, None]
空数组解析为列表: []
仅含一个空值的数组解析为列表: [None]