解释正则表达式

Question

我正在尝试记录一个使用常规表达式的验证规则的英文解释。我有两个地方我搞不清楚，而且我到处都是searh，但找不到关于我在下面标识的表达式片段的任何信息：

[^<>()[\]\\.,;:\s@\""]

到目前为止，我(从上面的代码片段)解释的是，它列出了不允许的字符，即[^ and ]之间的字符。有一组双反斜杠，这意味着一个反斜杠字符。我不能理解的部分是我看到的表示空白的\s@\""，我假设@是它所代表的字符，但我不知道\""是什么意思。我也不确定s@周围的反斜杠是不是某种分隔符，这改变了我上面的解释。

另一条我不能解释的是：

\"".+\""

没有\“或\”的定义(至少我能找到)，我的印象是反斜杠不应该是独立的，也就是说，它们要么转义某个特殊字符，要么成对使用来表示反斜杠本身。

如果有用的话，完整的正则表达式是：

^((([^<>()[\]\\.,;:\s@\""]+(\.[^<>()[\]\\.,;:\s@\""]+)*)|(\"".+\""))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,})))$

谢谢你的帮助！

Answer 1

这个正则表达式可能是用这样一种语言编写的，在这种语言中，双引号字符通过将两个字符放在一起进行转义。我想可能是VB(.Net)做的..？

在这种情况下，这种语言会将\""解析为\"，然后在正则表达式中解析为"。

Answer 2

正则表达式可能很难理解

基本上，正方形的parentesis []意味着表达式将匹配其中的任何字符。\s表示空格的表达式

试试http://www.regular-expressions.info/

此外，我可以强烈推荐Regex Buddy，它也有表达式的措辞。它还会为您生成代码，以确保正确转义字符。

由于\既是编程语言中的转义字符，又是用于定义表达式中的内容的字符，因此您可能会遇到一些使表达式难以阅读的情况。

看起来这就是您在使用\""时遇到的问题

另一部分：\"".+\""似乎与double quote followed by any character one to unlimited times and then ending in another double quote相匹配，问题在于你使用的编程语言如何确保在表达式中获得这些双count，而不是我认为的代码。

Answer 3

给定原始正则表达式：

^((([^<>()[\]\\.,;:\s@\""]+(\.[^<>()[\]\\.,;:\s@\""]+)*)|(\"".+\""))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,})))$

我已经破译了这一点，并以自由空格模式和注释写出了它。我在这里以Python的原始文本格式表示它，这样您就可以看到原生正则表达式被呈现给正则表达式引擎(在字符串解释之后)：

在原生正则表达式中注释的原始表达式：

re_commented = r'''
    # Match an email address.
    ^                                 # Anchor to start of string.
    (                                 # ($1:) Entire string.
      (                               # $2: FIRST PART (before @).
        ( [^<>()[\]\\.,;:\s@\""]+     # ($3:) Either one
          (                           # ($4:) or more
            \.                        #       dot separated
            [^<>()[\]\\.,;:\s@\""]+   #       parts.
          )*                          # ($4:)
        )                             # ($3:)
      | (                             # ($5:) Or FIRST PART is
          \"".+\""                    # a doubly, double quoted string.
        )                             # ($5:)
      )                               # $2: FIRST PART (before @).
      @                               # Required @ separates parts.
      (                               # $6: LAST PART (after @).
        ( \[                          # ($7:) LAST PART is Either
          [0-9]{1,3}\.                # an IPv4 domain address
          [0-9]{1,3}\.                # (i.e. 10.0.0.255)
          [0-9]{1,3}\.                # between
          [0-9]{1,3}                  # square
          \]                          # brackets.
        )                             # ($7:)
      | (                             # ($8:) Or LAST PART is
          ([a-zA-Z\-0-9]+\.)+         # a DNS style dot separated
          [a-zA-Z]{2,}                # named domain.
        )                             # ($8:)
      )                               # $6: LAST PART (after @).
    )                                 # ($1:) Entire string.
    $                                 # Anchor to end of string.
    '''

现在您可以清楚地看到，此正则表达式正在尝试验证电子邮件地址。似乎有人已经进入并编辑了该文件，并破坏了双引号-(正如正则表达式引擎看到的那样，\""的每个实例都应该是" )。还要注意，当在字符类中时，\""序列不会有任何影响，因为它等同于双引号的单个实例。然而，当它出现在电子邮件第一部分的第二个替代部分，即\"".+\""时，它就会引起麻烦。这里是一个修正的版本，修复了双引号的问题。我在这里以自由空间模式完整地注释了它，并以Java代码片段的形式演示了所有引号和反斜杠的正确转义。

已修复Java regex字符串中注释的表达式：

Pattern re_valid = Pattern.compile(
    "    # Match an email address. (Rev:20121105_1100 fixed quotes.)        \n" +
    "    ^                                     # Anchor to start of string. \n" +
    "    (                                     # ($1:) Entire string.       \n" +
    "      (                                   # $2: FIRST PART (before @). \n" +
    "        ( [^<>()\\[\\]\\\\.,;:\\s@\"]+    # ($3:) Either one           \n" +
    "          (                               # ($4:) or more              \n" +
    "            \\.                           #       dot separated        \n" +
    "            [^<>()\\[\\]\\\\.,;:\\s@\"]+  #       parts.               \n" +
    "          )*                              # ($4:)                      \n" +
    "        )                                 # ($3:)                      \n" +
    "      | (                                 # ($5:) Or FIRST PART is     \n" +
    "          \".+\"                          # a double quoted string.    \n" +
    "        )                                 # ($5:)                      \n" +
    "      )                                   # $2: FIRST PART (before @). \n" +
    "      @                                   # Required @ separates parts.\n" +
    "      (                                   # $6: LAST PART (after @).   \n" +
    "        ( \\[                             # ($7:) LAST PART is Either  \n" +
    "          [0-9]{1,3}\\.                   # an IPv4 domain address     \n" +
    "          [0-9]{1,3}\\.                   # (i.e. 10.0.0.255)          \n" +
    "          [0-9]{1,3}\\.                   # between                    \n" +
    "          [0-9]{1,3}                      # square                     \n" +
    "          \\]                             # brackets.                  \n" +
    "        )                                 # ($7:)                      \n" +
    "      | (                                 # ($8:) Or LAST PART is      \n" +
    "          ([a-zA-Z\\-0-9]+\\.)+           # a DNS style dot separated  \n" +
    "          [a-zA-Z]{2,}                    # named domain.              \n" +
    "        )                                 # ($8:)                      \n" +
    "      )                                   # $6: LAST PART (after @).   \n" +
    "    )                                     # ($1:) Entire string.       \n" +
    "    $                                     # Anchor to end of string.   ", 
    Pattern.COMMENTS);

请注意，这个正则表达式还有其他主要是次要的问题(谷歌“电子邮件验证”了解更多信息)。此外，许多分组括号也是不必要的。

最后一点- Java在编写和注释正则表达式时很糟糕！