正则表达式以递归方式捕获这些模式

Question

    java.util.regex.Pattern ips
        = java.util.regex.Pattern.compile("(\d{1,3}(?:\.\d{1,3}){2}\.(\d{1,3}))(?:(?:-|\s+to\s+)(\d{1,3}(?![\d\.]))|(?:-|\s*to\s+)(\d{1,3}(?:\.\d{1,3}){3})|\s+(25\d(?:\.\d{1,3}){3})|\s*\/(\d{1,3}))?");

目前我的 Regex 将接受以下类型的 IP 地址输入，但一次只能接受一种输入类型：

ip: "47.1.2.3"
范围：“47.1.2.3-4”
ip 范围：“47.1.2.3-47.1.2.4”
ip 范围：“47.1.2.3 到 4”
ip 到 ip 范围：“47.1.2.3 到 47.1.2.4”
IP CIDR：“47.1.2.4/32”
ip掩码：“47.1.2.4 255.255.255.255”

我想修改我的正则表达式以接受用逗号或 space 分隔的这些组合。理想情况下，正则表达式会按照上面列出的方式命名捕获组，以便于处理。

我希望以下内容也是有效输入，但我希望能够提取上述与命名组的匹配项。

"47.1.2.3 to 4, 47.1.2.7, 47.1.3.9-47.1.3.19"

我正在尝试使用正则表达式来验证文本字段中的输入。以下代码是文本字段：

public class HostCollectionTextField extends JFormattedTextField implements CellEditor, MouseListener {

ArrayList listeners = new ArrayList();
HostCollection hc;
java.util.regex.Pattern ips
        = java.util.regex.Pattern.compile("(\d{1,3}(?:\.\d{1,3}){2}\.(\d{1,3}))(?:(?:-|\s+to\s+)(\d{1,3}(?![\d\.]))|(?:-|\s*to\s+)(\d{1,3}(?:\.\d{1,3}){3})|\s+(25\d(?:\.\d{1,3}){3})|\s*\/(\d{1,3}))?");

public HostCollectionTextField() {
    this.addMouseListener(this);
    this.hc = new HostCollection();

    this.setFormatterFactory(new AbstractFormatterFactory() {

        @Override
        public JFormattedTextField.AbstractFormatter getFormatter(JFormattedTextField tf) {
            RegexFormatter f = new RegexFormatter(ips);
            return f;
        }
    });
    this.getDocument().addDocumentListener(new DocListener(this));
    addActionListener(new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent ae) {
            if (stopCellEditing()) {
                fireEditingStopped();
            }
        }
    });

}

//class 方法.... }

这是 RegexFormatter Class:

public class RegexFormatter extends DefaultFormatter {

protected java.util.regex.Matcher matcher;

public RegexFormatter(java.util.regex.Pattern regex) {
    setOverwriteMode(false);
    matcher = regex.matcher(""); // create a Matcher for the regular expression
}

public Object stringToValue(String string) throws java.text.ParseException {
    if (string == null) {
        return null;
    }
    matcher.reset(string); // set 'string' as the matcher's input

    if (!matcher.matches()) // Does 'string' match the regular expression?
    {
        throw new java.text.ParseException("does not match regex", 0);
    }

    // If we get this far, then it did match.
    return super.stringToValue(string); // will honor the 'valueClass' property
}

}

Answer 1

ip部分比较独特，应该没问题
比赛期间使用空格 and/or 逗号作为分隔符的重叠部分。

您可能需要同一个正则表达式的两个版本。
一个用于验证，一个用于提取。

要提取的只是您在全局匹配中使用的原始正则表达式。
这在验证后使用。

验证一个在下面。它使用
一次匹配多个 ip 部分锚 ^$ 与嵌入在 using
之间的原始量化正则表达式所需的分隔符 [\s,]+。

不确定这是否适用于您的验证码，但如果输入现在一个单独的 ip 部分，工作，那么这应该。

验证正则表达式：

"^(?:\d{1,3}(?:\.\d{1,3}){2}\.\d{1,3}(?:(?:-|\s+to\s+)\d{1,3}(?![\d\.])|(?:-|\s*to\s+)\d{1,3}(?:\.\d{1,3}){3}|\s+25\d(?:\.\d{1,3}){3}|\s*\/\d{1,3})?(?:[\s,]*$|[\s,]+))+$"

格式化：

 ^     
 (?:
      \d{1,3} 
      (?: \. \d{1,3} ){2}
      \.
      \d{1,3} 
      (?:
           (?: - | \s+ to \s+ )
           \d{1,3} 
           (?! [\d\.] )
        |  
           (?: - | \s* to \s+ )
           \d{1,3} 
           (?: \. \d{1,3} ){3}
        |  
           \s+ 
           25 \d 
           (?: \. \d{1,3} ){3}
        |  
           \s* \/
           \d{1,3} 
      )?

      (?:
           [\s,]* $ 
        |  
           [\s,]+  
      )
 )+
 $

编辑： 将组名添加到提取正则表达式。

 # "(?<IP>\d{1,3}(?:\.\d{1,3}){2}\.(?<From_Seg>\d{1,3}))(?:(?:-|\s+to\s+)(?<To_Seg>\d{1,3}(?![\d\.]))|(?:-|\s*to\s+)(?<To_Range>\d{1,3}(?:\.\d{1,3}){3})|\s+(?<Mask>25\d(?:\.\d{1,3}){3})|\s*/(?<Port>\d{1,3}))?"

 (?<IP>                        # (1), IP
      \d{1,3} 
      (?: \. \d{1,3} ){2}
      \.
      (?<From_Seg> \d{1,3} )        # (2), From segment
 )
 (?:
      (?: - | \s+ to \s+ )
      (?<To_Seg>                    # (3), Dash/To segment
           \d{1,3} 
           (?! [\d\.] )
      )
   |  
      (?: - | \s* to \s+ )
      (?<To_Range>                  # (4), Dash/To range
           \d{1,3} 
           (?: \. \d{1,3} ){3}
      )
   |  
      \s+     
      (?<Mask>                      # (5), Mask
           25 \d 
           (?: \. \d{1,3} ){3}
      )
   |  
      \s* /     
      (?<Port>                      # (6), Port
           \d{1,3} 
      )
 )?

正则表达式以递归方式捕获这些模式

Regex to catch these patterns recursively

regex

regex-greedy