如果代码存在，正则表达式抓取文本

Question

我正在尝试构建一个正则表达式来添加代码值（如果代号存在）

说个例子：

{(en56), (sc45), (da77), (cd29)}
{(en56), (sc45), (cd29)}

我会写一个正则表达式 {[(]en(?<en>\d{2}).*[(]sc(?<sc>\d{2}).*[(]da(?<da>\d{2}).*[(]cd(?<cd>\d{2}).*

无论如何我都会抓住第一行，因为它匹配并且标记的结果将被提取。如果输入没有它，如何保持 da 为可选。

当我尝试使用 ? 时，它基本上消除了第一个结果中的值 {[(]en(?<en>\d{2}).*[(]sc(?<sc>\d{2}).*([(]da(?<da>\d{2}))?.*[(]cd(?<cd>\d{2}).*

Answer 1

您可以通过将正则表达式的那部分包含在 non-capturing group 中并使用 ? 量词来使其成为可选的，该量词与它量化的子模式的一次或零次匹配：

{[(]en(?<en>\d{2}).*[(]sc(?<sc>\d{2})(?:.*[(]da(?<da>\d{2}))?.*[(]cd(?<cd>\d{2}).*
                                     ^^^                   ^^

见regex demo

如果需要，您可以使用此技术使正则表达式的更多部分成为可选的。

Answer 2

新答案

我刚刚注意到您正在使用 Qt 正则表达式。
因为，Qt 使用 PCRE 引擎，你可以利用条件
不仅可以选择性地查找项目，还可以找到它们 Out-Of-Order.
无论它们是否有序，它仍然会找到它们。

所以，所有的基地都被覆盖了。然后你看看一些高级的
正则表达式技术。

想法是找到 1-4 个项目。这是通过组构造和
完成的范围量词 (?: ... | ... | ... | ...){1,4}

上限 4 因为那是组中的项目数。

最后，每个项目都受到保护，并有条件确保
item 再次匹配不上。这是为了保证上限4
指的是独特的项目，而 range 使每个项目都是可选的。

这样做的附带好处是每个项目都可以匹配乱序
这意味着它在源文本中出现的项目顺序
无关紧要。

祝你好运！希望你有机会尝试一下..

Formatted and tested:

 #  {(?:.*?(?:(?(<en>)(?!))[(]en(?<en>\d{2})|(?(<sc>)(?!))[(]sc(?<sc>\d{2})|(?(<da>)(?!))[(]da(?<da>\d{2})|(?(<cd>)(?!))[(]cd(?<cd>\d{2}))){1,4}

 # Match 1-4 'Out-Of-Order' unique items
 # --------------------------------------------
 {
 (?:                  # Cluster start - loop to find out of order items
      .*? 
      (?:
           (?(<en>)             # Condition, not matched 'en' before
                (?!)
           )
           [(] en
           (?<en> \d{2} )       # (1)
        |                     # or,
           (?(<sc>)             # Condition, not matched 'sc' before
                (?!)
           )
           [(] sc
           (?<sc> \d{2} )       # (2)
        |                     # or,
           (?(<da>)             # Condition, not matched 'da' before
                (?!)
           )
           [(] da
           (?<da> \d{2} )       # (3)
        |                     # or,
           (?(<cd>)             # Condition, not matched 'cd' before
                (?!)
           )
           [(] cd
           (?<cd> \d{2} )       # (4)
      )
 ){1,4}               # Cluster end - find  1 to 4 unique items

测试输入

{(sc45), (en56), (da77), (cd29)}
{(da77), (cd29)}
{(en56), (sc45), (cd29)}
{(da77), (cd29) (en56), (sc45)}
{(sc45)}
{(en56), (cd29), (sc45)}

输出

 **  Grp 0      -  ( pos 0 , len 30 ) 
{(sc45), (en56), (da77), (cd29  
 **  Grp 1 [en] -  ( pos 12 , len 2 ) 
56  
 **  Grp 2 [sc] -  ( pos 4 , len 2 ) 
45  
 **  Grp 3 [da] -  ( pos 20 , len 2 ) 
77  
 **  Grp 4 [cd] -  ( pos 28 , len 2 ) 
29
------------  
 **  Grp 0      -  ( pos 34 , len 14 ) 
{(da77), (cd29  
 **  Grp 1 [en] -  NULL 
 **  Grp 2 [sc] -  NULL 
 **  Grp 3 [da] -  ( pos 38 , len 2 ) 
77  
 **  Grp 4 [cd] -  ( pos 46 , len 2 ) 
29  
------------  
 **  Grp 0      -  ( pos 52 , len 22 ) 
{(en56), (sc45), (cd29  
 **  Grp 1 [en] -  ( pos 56 , len 2 ) 
56  
 **  Grp 2 [sc] -  ( pos 64 , len 2 ) 
45  
 **  Grp 3 [da] -  NULL 
 **  Grp 4 [cd] -  ( pos 72 , len 2 ) 
29  
------------  
 **  Grp 0      -  ( pos 78 , len 29 ) 
{(da77), (cd29) (en56), (sc45  
 **  Grp 1 [en] -  ( pos 97 , len 2 ) 
56  
 **  Grp 2 [sc] -  ( pos 105 , len 2 ) 
45  
 **  Grp 3 [da] -  ( pos 82 , len 2 ) 
77  
 **  Grp 4 [cd] -  ( pos 90 , len 2 ) 
29  
------------  
 **  Grp 0      -  ( pos 111 , len 6 ) 
{(sc45  
 **  Grp 1 [en] -  NULL 
 **  Grp 2 [sc] -  ( pos 115 , len 2 ) 
45  
 **  Grp 3 [da] -  NULL 
 **  Grp 4 [cd] -  NULL 
------------  
 **  Grp 0      -  ( pos 121 , len 22 ) 
{(en56), (cd29), (sc45  
 **  Grp 1 [en] -  ( pos 125 , len 2 ) 
56  
 **  Grp 2 [sc] -  ( pos 141 , len 2 ) 
45  
 **  Grp 3 [da] -  NULL 
 **  Grp 4 [cd] -  ( pos 133 , len 2 ) 
29

基准

Regex1:   {(?:.*?(?:(?(<en>)(?!))[(]en(?<en>\d{2})|(?(<sc>)(?!))[(]sc(?<sc>\d{2})|(?(<da>)(?!))[(]da(?<da>\d{2})|(?(<cd>)(?!))[(]cd(?<cd>\d{2}))){1,4}
Options:  < none >
Completed iterations:   50  /  50     ( x 1000 )
Matches found per iteration:   6
Elapsed Time:    3.41 s,   3411.71 ms,   3411714 µs

如果代码存在，正则表达式抓取文本

regex to grab text if code exists

regex

regex-greedy