简化复杂的正则表达式

Question

I am looking for a way to simplify a regular expression which consists of values (eg 12345), relation signs (<,>,<=,>=) and junctors (&,!). Eg the expression:

>= 12345 & <=99999 & !55555 

should be matched. I have this regular expression:

(^<=|^<= | ^>= | ^>= |^<|^>|^< |^> |^)((!|)([0-9]{1,5}))( & > | & < |& >=|&>=|&<=||&<=|&>=|&<|&>|&| &| & |$))*

I am especially unhappy with the repetition of <=, >=, <, > at the beginning and end of the expression. I would be glad to get a hint how to make it simpler eg look ahead, look back.

Answer 1

Starting from your regex, you can do this simplification steps:

 (^<=|^<= | ^>= | ^>= |^<|^>|^< |^> |^)((!|)([0-9]{1,5}))( & > | & < |& >=|&>=|&<=||&<=|&>=|&<|&>|&| &| & |$))*

1. Move the anchor out of the alternation

    ^(<=|<= |>= |>= |<|>|< |> |)((!|)([0-9]{1,5}))( & > | & < |& >=|&>=|&<=||&<=|&>=|&<|&>|&| &| & |$))* 

   Why has there been whitespace before the anchor? (removed that)

2. Move the following whitespace outside and make it optional

    ^(<=|<=|>=|>=|<|>|<|>|) ?((!|)([0-9]{1,5}))( & > | & < |& >=|&>=|&<=||&<=|&>=|&<|&>|&| &| & |$))* 

3. Remove the duplicates in the alternations

    ^(<=|>=|<|>|) ?((!|)([0-9]{1,5}))( & > | & < |& >=|&>=|&<=||&<=|&>=|&<|&>|&| &| & |$))* 

4. The empty alternative at the end would match the empty string ==> this alternation is optional

    ^((<=|>=|<|>)? ?)?((!|)([0-9]{1,5}))( & > | & < |& >=|&>=|&<=||&<=|&>=|&<|&>|&| &| & |$))* 

5. Make the equal sign optional and remove the duplicates

    ^((<|>)=? ?)?((!|)([0-9]{1,5}))( & > | & < |& >=|&>=|&<=||&<=|&>=|&<|&>|&| &| & |$))* 

6. The alternation with single characters can be replaced with a character class

    ^([<>]=? ?)?((!|)([0-9]{1,5}))( & > | & < |& >=|&>=|&<=||&<=|&>=|&<|&>|&| &| & |$))* 

7. Do similar things with the alternation at the end and you end up with something like this:

    ^([<>]=? ?)?((!|)([0-9]{1,5}))( ?(& ?([<>]=?)?)?|$) 

This is untested, I did not change the semantic (I think so), but I did this just here in the editor.

Answer 2

You can make all the spaces optional (with question marks) so you don't have to explicitly list all the possibilities. Also you can group the equality/inequality symbols in a character set ([ ]).

Like this, I think

(^[<>]=?\s?)((!|)([0-9]{1,5}))(\s?&\s?[<>]=?\s|$)*

Answer 3

How about

[<>]=?|\\d{1,5}|[&!\\|]

That takes care of your > / >= / < / <= repetition. Seems to work for me.

Let me know if this answers your question, or needs work.

Answer 4

I have a two-step procedure in mind. First break by junctor, then check individual parts.

final String expr = ">= 12345 & <=99999 & !55555".replaceAll("\\s+", "");
for (String s : expr.split("[|&]"))
  if (!s.matches("([<>]=?|=|!)?\\d+")) { System.out.println("Invalid"); return; }
System.out.println("Valid");

But we're still left guessing whether you are talking about validation or something else.

Answer 5

you seem to be spending a lot of effort matching optional spaces. something like \\s? (0 - 1) or \\s* (0 - many) would be better.

also, repeated items separated by something are always difficult. it's best to make a regexp for the "thing" to simplify the repetition.

limit = '\s*([<>]=?|!)\s*\d{1,5}\s*'
one_or_more = '^' + limit + '(&' + limit + ')*$'

or, expanded out:

^\s*([<>]=?|!)\s*\d{1,5}\s*(&\s*([<>]=?|!)\s*\d{1,5}\s*)*$

also, ! is a "relation sign" and not a "junctor" if i am understanding correctly.

(for the people advocating using a "real" parser, the above - the structure of one_or_more - is probably how you would end up implementing the &-separated list; there's no need for a parser if you can just use string concatenation in the language).

Answer 6

This is what you want:

^(\s*([<>]=?)?\s*!?\d{1,5}\s*(&|$))*

These explanations of sum sub expressions should help you understand the whole thing:

\\s* : 0 or more spaces
([<>]=?)? : A < or > sign optionally followed by an = , all optional
!? : And optional !
\\d{1,5} : 1-5 digits
(&|$) : Either an & or the end of the string