Регулярное выражение шаблон для соответствия, исключая когда... / кроме между

сделайте три разных совпадения и обработайте комбинацию из трех ситуаций, используя условную логику в программе. Вам не нужно обрабатывать все в одном гигантском регулярном выражении.

EDIT: позвольте мне немного расширить, потому что вопрос просто стал более интересным : -)

общая идея, которую вы пытаетесь захватить здесь, состоит в том, чтобы соответствовать определенному шаблону регулярного выражения, но не тогда, когда в тестовой строке присутствуют определенные другие (могут быть любые числа) шаблоны. К счастью, вы можете воспользоваться вашим языком программирования: держите регулярные выражения простыми и просто используйте составное условие. Лучше всего было бы захватить эту идею в многоразовом компоненте, поэтому давайте создадим класс и метод, который его реализует:

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));
    }
  }
}

Итак, выше мы настроили строку поиска (пять цифр), несколько строк исключений (ваш s1, s2 и s3), а затем попробуйте сопоставить несколько тестовых строк. Результат печати должно быть, как показано в комментариях рядом с каждой строкой теста.

ваше требование, что это не внутри parens в Невозможно насытить для всех случаев. А именно, если вы можете как-то найти ( слева и ) справа, это не всегда означает, что вы находитесь внутри скобок. Например.

(....) + 55555 + (.....) - не внутри parens еще есть ( и ) и

теперь вы можете считать себя умным и искать ( влево, только если вы не сталкиваетесь ) перед и наоборот справа. Этот не будет работать в этом случае:

((.....) + 55555 + (.....)) - внутри скобок, даже если есть закрывающий тег ) и ( влево и вправо.

невозможно узнать, находитесь ли вы внутри parens с помощью regex, так как regex не может подсчитать, сколько parens было открыто и сколько закрыто.

рассмотрим эту более простую задачу: используя регулярное выражение, выясните, закрыты ли все (возможно, вложенные) парены в строке, то есть для каждого ( вам нужно найти ). Вы найдете из того, что это невозможно решить, и если вы не можете решить это с помощью регулярного выражения, то вы не можете выяснить, находится ли слово внутри parens для всех случаев, так как вы не можете выяснить в какой-то позиции в строке, если все предшествующие ( иметь соответствующую ).

Ганс, если вы не возражаете, я использовал стиральную машину вашего соседа под названием 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

дан входной файл.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. я использовал стек, чтобы отслеживать if( блоки.

ок, вот решение -

я использовал C# и с ним MEF (Microsoft Extensibility Framework) для реализации настраиваемых парсеров. Идея заключается в том, чтобы использовать один синтаксический анализатор для анализа и список настраиваемых классов валидаторов для проверки строки и возврата 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. затем идет средство чтения файлов и проверки -

   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. затем идет реализация отдельных шашек, имена классов не требуют пояснений, поэтому я не думаю, что они нужно больше описаний.

   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. программы

   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();
           }
       }
   }
   

для тестирования я взял образец файла @Tiago как Test.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

дает на выходе -

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

не знаю, поможет ли это вам или нет, я весело провел время, играя с ним.... :)

лучшая часть заключается в том, что для добавления нового состояния все, что вам нужно сделать, это предоставить реализация IPatternMatcher, он будет автоматически вызываться и, таким образом, будет проверять.

то же, что и @zx81 (*SKIP)(*F) но с использованием отрицательного утверждения lookahead.

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

демо

в python, я бы сделал легко, как это,

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