.net 正则表达式在右参数上失败

我有一个.NET正则表达式：

^(?<prefix>("[^"]*"))\s(?<attrgroup>(\([^\)]*\)))\s(?<suffix>("[^"]*"))$

它在……上失败了

"some prefix" ("attribute 1" "value (fail) 1") "some suffix"

…由于“失败”后的正确选项

如何修改正则表达式，使

attrgroup

匹配组最终包含“

（“属性1”值（失败）1”）

”？我看了太久了，需要一些新鲜的眼睛。谢谢

编辑：

attrgroup

将不包含除双引号字符串对以外的任何内容。

^（？“[^”]*”）\s+（？\（.*））\s+（？“[^”]*”）$
^(?<prefix>"[^"]*")\s+(?<attrgroup>\(.*\))\s+(?<suffix>"[^"]*")$

帮我修好了

我删除了无关的未命名组，并简化了属性组（简化为“任意字符”）

JG Soft的RegexBuddy是一项非常有价值的投资

编辑：这不会将属性组验证为带引号的字符串对，但这应该/可以在单独的正则表达式/验证步骤中完成。

^（？“[^”]*”）\s+（？\（.\）\s+（？“[^”]*”）$

帮我修好了

我删除了无关的未命名组，并简化了属性组（简化为“任意字符”）

JG Soft的RegexBuddy是一项非常有价值的投资

---

编辑：这不会将属性组验证为带引号的字符串对，但这应该/可以在单独的正则表达式/验证步骤中完成。

Hometoasts解决方案是一个很好的解决方案，尽管像任何自由的正则表达式一样，它应该只用于从您有合理保证的源中提取数据，并且格式良好，不用于验证。

Hometoasts解决方案是一个很好的解决方案，尽管像任何自由的正则表达式一样，它应该只用于从您有合理保证的源中提取数据，而不是用于验证。

如果不涉及此正则表达式的细节，我建议使用正则表达式工具来帮助构建、测试和验证正则表达式。对于任何非琐碎的东西，或者您可能需要维护/更新的表达式，这些工具都是必不可少的

退房

-用Lisp编写，有点老，但我真的更喜欢这个

---

-.NET，也许更“现代”。有些人可能喜欢这一个。

如果不讨论这个正则表达式的细节，我建议使用正则表达式工具来帮助构建、测试和验证正则表达式。对于任何非琐碎的东西，或者您可能需要维护/更新的表达式，这些工具都是必不可少的

退房

-用Lisp编写，有点老，但我真的更喜欢这个

-.NET，也许更“现代”。有些人可能喜欢这个。

我未经测试的猜测：

^(?<prefix>("[^"]*"))\s(?<attrgroup>(\(("[^"]*")(\s("[^"]*")*)**\)))\s(?<suffix>("[^"]*"))$

与

我假设括号内的所有内容要么在双引号之间，要么是空白

如果你想知道我是怎么想到这个的，请阅读

如果我是正确的，那么这也将验证属性组作为引用字符串对。

我的未测试猜测：

^(?<prefix>("[^"]*"))\s(?<attrgroup>(\(("[^"]*")(\s("[^"]*")*)**\)))\s(?<suffix>("[^"]*"))$

与

我假设括号内的所有内容要么在双引号之间，要么是空白

如果你想知道我是怎么想到这个的，请阅读

---

如果我是正确的，那么这也将验证属性组作为引用字符串对。

我建议使用能够处理此类结构的解析器。正则表达式失败了，这是正确的，因为您尝试解析的语言看起来不是正则的——至少从上面给出的示例来看是如此。每当您需要识别嵌套时，regexp要么会失败，要么会成长为像上面那样的复杂野兽。即使语言是正则的，上面的正则表达式对我来说也太复杂了。我宁愿用这样的东西：

def parse_String(string):
    index = skip_spaces(string, 0)
    index, prefix = read_prefix(string, index)
    index = skip_spaces(string, index)
    index, attrgroup = read_attrgroup(string, index)
    index = skip_spaces(string, index)
    index, suffix = read_suffix(string, index)
    return prefix, attrgroup, suffix

def read_prefix(string, start_index):
    return read_quoted_string(string, start_index) 

def read_attrgroup(string, start_index):
    end_index, content = read_paren(string, start_index)

    index = skip_spaces(content, 0)
    index, first_entry = read_quoted_string(content, index)
    index = skip_spaces(content, index)
    index, second_entry = read_quoted_string(content, index)
    return end_index, (first_entry, second_entry)


def read_suffix(string, start_index):
    return read_quoted_string(string, start_index)

def read_paren(string, start_index):
    return read_delimited_string(string, start_index, '(', ')')

def read_quoted_string(string, start_index):
    return read_delimited_string(string, start_index, '"', '"')

def read_delimited_string(string, starting_index, start_limiter, end_limiter):
    assert string[starting_index] == start_limiter, (start_limiter 
                                                     +"!=" 
                                                     +string[starting_index])
    current_index = starting_index+1
    content = ""
    while(string[current_index] != end_limiter):
        content += string[current_index]
        current_index += 1

    assert string[current_index] == end_limiter
    return current_index+1, content

def skip_spaces(string, index):
    while string[index] == " ":
        index += 1
    return index

是的，这是更多的代码，是的，根据原始的键数，这需要更长的时间。然而——至少对我来说——我的解决方案更容易验证。若您通过将所有字符串和索引管道移动到类中来移除一组字符串和索引管道，则这会增加更多，类在其构造函数中解析此类字符串。此外，很容易使空格跳过隐式（使用一些神奇的next char方法，它只跳过字符直到出现非空格，除非它由于字符串而处于某种非跳过模式。例如，可以在分隔函数中设置该模式）。这将把parse_字符串转换为：

def parse_string(string):
    prefix = read_prefix()
    attrgroup = read_attr_group()
    suffix = read_suffix()
    return prefix, attrgroup, suffix.

此外，此函数可以更容易地扩展，以覆盖更复杂的表达式。任意嵌套属性组？更改一行代码。嵌套帕伦斯？多做一点工作，但没有真正的问题

现在，请为我是一些正则表达式异教徒和解析器拥护者而大发雷霆并投票否决我。>：）

---

PS：是的，该代码未经测试。据我所知，其中有3个我没有看到的拼写错误。

我建议使用能够处理此类结构的解析器。正则表达式失败了，这是正确的，因为您尝试解析的语言看起来不是正则的——至少从上面给出的示例来看是如此。每当您需要识别嵌套时，regexp要么会失败，要么会成长为像上面那样的复杂野兽。即使语言是正则的，上面的正则表达式对我来说也太复杂了。我宁愿用这样的东西：

def parse_String(string):
    index = skip_spaces(string, 0)
    index, prefix = read_prefix(string, index)
    index = skip_spaces(string, index)
    index, attrgroup = read_attrgroup(string, index)
    index = skip_spaces(string, index)
    index, suffix = read_suffix(string, index)
    return prefix, attrgroup, suffix

def read_prefix(string, start_index):
    return read_quoted_string(string, start_index) 

def read_attrgroup(string, start_index):
    end_index, content = read_paren(string, start_index)

    index = skip_spaces(content, 0)
    index, first_entry = read_quoted_string(content, index)
    index = skip_spaces(content, index)
    index, second_entry = read_quoted_string(content, index)
    return end_index, (first_entry, second_entry)


def read_suffix(string, start_index):
    return read_quoted_string(string, start_index)

def read_paren(string, start_index):
    return read_delimited_string(string, start_index, '(', ')')

def read_quoted_string(string, start_index):
    return read_delimited_string(string, start_index, '"', '"')

def read_delimited_string(string, starting_index, start_limiter, end_limiter):
    assert string[starting_index] == start_limiter, (start_limiter 
                                                     +"!=" 
                                                     +string[starting_index])
    current_index = starting_index+1
    content = ""
    while(string[current_index] != end_limiter):
        content += string[current_index]
        current_index += 1

    assert string[current_index] == end_limiter
    return current_index+1, content

def skip_spaces(string, index):
    while string[index] == " ":
        index += 1
    return index

是的，这是更多的代码，是的，根据原始的键数，这需要更长的时间。然而——至少对我来说——我的解决方案更容易验证。若您通过将所有字符串和索引管道移动到类中来移除一组字符串和索引管道，则这会增加更多，类在其构造函数中解析此类字符串。此外，很容易使空格跳过隐式（使用一些神奇的next char方法，它只跳过字符直到出现非空格，除非它由于字符串而处于某种非跳过模式。例如，可以在分隔函数中设置该模式）。这将把parse_字符串转换为：

def parse_string(string):
    prefix = read_prefix()
    attrgroup = read_attr_group()
    suffix = read_suffix()
    return prefix, attrgroup, suffix.

此外，此函数可以更容易地扩展，以覆盖更复杂的表达式。任意嵌套属性组？更改一行代码。嵌套帕伦斯？多做一点工作，但没有真正的问题

现在，请为我是一些正则表达式异教徒和解析器倡导者而谴责我