Regex Pattern to Match, Excluding when... / Except between

进行三种不同的匹配，并使用程序内条件逻辑处理这三种情况的组合。您不需要在一个巨大的正则表达式中处理所有事情。

编辑: 让我展开一点，因为这个问题变得更有趣了: -)

The general idea you are trying to capture here is to match against a certain regex pattern, but not when there are certain other (could be any number) patterns present in the test string. Fortunately, you can take advantage of your programming language: keep the regexes simple and just use a compound conditional. A best practice would be to capture this idea in a reusable component, so let's create a class and a method that implement it:

using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;


public class MatcherWithExceptions {
private string m_searchStr;
private Regex m_searchRegex;
private IEnumerable<Regex> m_exceptionRegexes;


public string SearchString {
get { return m_searchStr; }
set {
m_searchStr = value;
m_searchRegex = new Regex(value);
}
}


public string[] ExceptionStrings {
set { m_exceptionRegexes = from es in value select new Regex(es); }
}


public bool IsMatch(string testStr) {
return (
m_searchRegex.IsMatch(testStr)
&& !m_exceptionRegexes.Any(er => er.IsMatch(testStr))
);
}
}


public class App {
public static void Main() {
var mwe = new MatcherWithExceptions();


// Set up the matcher object.
mwe.SearchString = @"\b\d{5}\b";
mwe.ExceptionStrings = new string[] {
@"\.$"
, @"\(.*" + mwe.SearchString + @".*\)"
, @"if\(.*" + mwe.SearchString + @".*//endif"
};


var testStrs = new string[] {
"1." // False
, "11111." // False
, "(11111)" // False
, "if(11111//endif" // False
, "if(11111" // True
, "11111" // True
};


// Perform the tests.
foreach (var ts in testStrs) {
System.Console.WriteLine(mwe.IsMatch(ts));
}
}
}

因此，上面我们设置了搜索字符串(5位数字)、多个异常字符串(中一、 第2条和 中三) ，然后尝试匹配多个测试字符串。打印的结果应该如每个测试字符串旁边的注释所示。

你的要求，它不在括号内在不可能满足所有情况。 也就是说，如果你能在左边找到一个 (，在右边找到一个 )，这并不总是意味着你在括号内。艾格。

(....) + 55555 + (.....)-不在括号内，但有 (和 )到左和右

现在你可能认为自己很聪明，只有当你之前没有遇到 )的时候才会在左边寻找 (，反之亦然。这对这个案子没用:

((.....) + 55555 + (.....))-内括号，即使有关闭 )和 (到左边和右边。

使用正则表达式不可能知道是否在括号内，因为正则表达式无法计算打开了多少个括号和关闭了多少个括号。

Consider this easier task: using regex, find out if all (possibly nested) parens in a string are closed, that is for every ( you need to find ). You will find out that it's impossible to solve and if you can't solve that with regex then you can't figure out if a word is inside parens for all cases, since you can't figure out at a some position in string if all preceeding ( have a corresponding ).

汉斯，如果你不介意的话，我用了你邻居的洗衣机，名字叫 perl:)

编辑: 下面是一个伪代码:

  loop through input
if line contains 'if(' set skip=true
if skip= true do nothing
else
if line match '\b\d{5}\b' set s0=true
if line does not match s1 condition  set s1=true
if line does not match s2 condition  set s2=true
if s0,s1,s2 are true print line
if line contains '//endif' set skip=false

给定文件 input.txt:

tiago@dell:~$ cat input.txt
this is a text
it should match 12345
if(
it should not match 12345
//endif
it should match 12345
it should not match 12345.
it should not match ( blabla 12345  blablabla )
it should not match ( 12345 )
it should match 12345

脚本 validator.pl:

tiago@dell:~$ cat validator.pl
#! /usr/bin/perl
use warnings;
use strict;
use Data::Dumper;


sub validate_s0 {
my $line = $_[0];
if ( $line =~ \d{5/ ){
return "true";
}
return "false";
}


sub validate_s1 {
my $line = $_[0];
if ( $line =~ /\.$/ ){
return "false";
}
return "true";
}


sub validate_s2 {
my $line = $_[0];
if ( $line =~ /.*?\(.*\d{5.*?\).*/ ){
return "false";
}
return "true";
}


my $skip = "false";
while (<>){
my $line = $_;


if( $line =~ /if\(/ ){
$skip = "true";
}


if ( $skip eq "false" ) {
my $s0_status = validate_s0 "$line";
my $s1_status = validate_s1 "$line";
my $s2_status = validate_s2 "$line";


if ( $s0_status eq "true"){
if ( $s1_status eq "true"){
if ( $s2_status eq "true"){
print "$line";
}
}
}
}


if ( $line =~ /\/\/endif/) {
$skip="false";
}
}

执行:

tiago@dell:~$ cat input.txt | perl validator.pl
it should match 12345
it should match 12345
it should match 12345

不知道这是否会帮助你或不，但我提供了一个解决方案，考虑到以下假设-

1. 您需要一个优雅的解决方案来检查所有条件
2. 未来和任何时候，情况都可能发生变化。
3. 一个条件不应该依赖于其他条件。

不过我还考虑了以下几点-

1. 给出的文件错误最少。如果是这样，那么我的代码可能需要一些修改来处理这个问题。
2. 我使用 Stack 来跟踪 if(块。

好吧，这就是解决办法

我使用 C # 和它的 MEF (Microsoft 扩展性框架)来实现可配置的解析器。其思想是，使用单个解析器进行解析，并使用一组可配置的验证器类来验证该行，并根据验证结果返回 true 或 false。然后您可以随时添加或删除任何验证器或添加新的，如果你喜欢。到目前为止，我已经实现了您提到的 S1、 S2和 S3，请检查第3点的类。如果将来需要，您必须为 s4、 s5添加类。

1. 首先，创建接口-

   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
   using System.Threading.Tasks;
   
   
   namespace FileParserDemo.Contracts
   {
   public interface IParser
   {
   String[] GetMatchedLines(String filename);
   }
   
   
   public interface IPatternMatcher
   {
   Boolean IsMatched(String line, Stack<string> stack);
   }
   }
   

2. Then comes the file reader and checker -

   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
   using System.Threading.Tasks;
   using FileParserDemo.Contracts;
   using System.ComponentModel.Composition.Hosting;
   using System.ComponentModel.Composition;
   using System.IO;
   using System.Collections;
   
   
   namespace FileParserDemo.Parsers
   {
   public class Parser : IParser
   {
   [ImportMany]
   IEnumerable<Lazy<IPatternMatcher>> parsers;
   private CompositionContainer _container;
   
   
   public void ComposeParts()
   {
   var catalog = new AggregateCatalog();
   catalog.Catalogs.Add(new AssemblyCatalog(typeof(IParser).Assembly));
   _container = new CompositionContainer(catalog);
   try
   {
   this._container.ComposeParts(this);
   }
   catch
   {
   
   
   }
   }
   
   
   public String[] GetMatchedLines(String filename)
   {
   var matched = new List<String>();
   var stack = new Stack<string>();
   using (StreamReader sr = File.OpenText(filename))
   {
   String line = "";
   while (!sr.EndOfStream)
   {
   line = sr.ReadLine();
   var m = true;
   foreach(var matcher in this.parsers){
   m = m && matcher.Value.IsMatched(line, stack);
   }
   if (m)
   {
   matched.Add(line);
   }
   }
   }
   return matched.ToArray();
   }
   }
   }
   

3. Then comes the implementation of individual checkers, the class names are self explanatory, so I don't think they need more descriptions.

   using FileParserDemo.Contracts;
   using System;
   using System.Collections.Generic;
   using System.ComponentModel.Composition;
   using System.Linq;
   using System.Text;
   using System.Text.RegularExpressions;
   using System.Threading.Tasks;
   
   
   namespace FileParserDemo.PatternMatchers
   {
   [Export(typeof(IPatternMatcher))]
   public class MatchAllNumbers : IPatternMatcher
   {
   public Boolean IsMatched(String line, Stack<string> stack)
   {
   var regex = new Regex("\\d+");
   return regex.IsMatch(line);
   }
   }
   
   
   [Export(typeof(IPatternMatcher))]
   public class RemoveIfBlock : IPatternMatcher
   {
   public Boolean IsMatched(String line, Stack<string> stack)
   {
   var regex = new Regex("if\\(");
   if (regex.IsMatch(line))
   {
   foreach (var m in regex.Matches(line))
   {
   //push the if
   stack.Push(m.ToString());
   }
   //ignore current line, and will validate on next line with stack
   return true;
   }
   regex = new Regex("//endif");
   if (regex.IsMatch(line))
   {
   foreach (var m in regex.Matches(line))
   {
   stack.Pop();
   }
   }
   return stack.Count == 0; //if stack has an item then ignoring this block
   }
   }
   
   
   [Export(typeof(IPatternMatcher))]
   public class RemoveWithEndPeriod : IPatternMatcher
   {
   public Boolean IsMatched(String line, Stack<string> stack)
   {
   var regex = new Regex("(?m)(?!\\d+.*?\\.$)\\d+");
   return regex.IsMatch(line);
   }
   }
   
   
   
   
   [Export(typeof(IPatternMatcher))]
   public class RemoveWithInParenthesis : IPatternMatcher
   {
   public Boolean IsMatched(String line, Stack<string> stack)
   {
   var regex = new Regex("\\(.*\\d+.*\\)");
   return !regex.IsMatch(line);
   }
   }
   }
   

4. The program -

   using FileParserDemo.Contracts;
   using FileParserDemo.Parsers;
   using System;
   using System.Collections.Generic;
   using System.ComponentModel.Composition;
   using System.IO;
   using System.Linq;
   using System.Text;
   using System.Threading.Tasks;
   
   
   namespace FileParserDemo
   {
   class Program
   {
   static void Main(string[] args)
   {
   var parser = new Parser();
   parser.ComposeParts();
   var matches = parser.GetMatchedLines(Path.GetFullPath("test.txt"));
   foreach (var s in matches)
   {
   Console.WriteLine(s);
   }
   Console.ReadLine();
   }
   }
   }
   

For testing I took @Tiago's sample file as Test.txt which had the following lines -

this is a text
it should match 12345
if(
it should not match 12345
//endif
it should match 12345
it should not match 12345.
it should not match ( blabla 12345  blablabla )
it should not match ( 12345 )
it should match 12345

给出输出-

it should match 12345
it should match 12345
it should match 12345

不知道这对你有没有帮助，我玩得很开心... ... :)

它最好的部分是，为了添加一个新条件，所有您必须做的就是提供一个 IPatternMatcher的实现，它将被自动调用，从而进行验证。

与@zx81的 (*SKIP)(*F)相同，但使用了负面的前瞻断言。

(?m)(?:if\(.*?\/\/endif|\([^()]*\))(*SKIP)(*F)|\b\d+\b(?!.*\.$)

演示

在巨蟒中，我很容易就会这样做,

import re
string = """cat 123 sat.
I like 000 not (456) though 111 is fine
222 if(  //endif if(cat==789 stuff  //endif   333"""
for line in string.split('\n'):                                  # Split the input according to the `\n` character and then iterate over the parts.
if not line.endswith('.'):                                   # Don't consider the part which ends with a dot.
for i in re.split(r'\([^()]*\)|if\(.*?//endif', line):   # Again split the part by brackets or if condition which endswith `//endif` and then iterate over the inner parts.
for j in re.findall(r'\b\d+\b', i):                  # Then find all the numbers which are present inside the inner parts and then loop through the fetched numbers.
print(j)                                         # Prints the number one ny one.

产出:

000
111
222
333