Regex - match group that contains word AND does not contain another word

[Ioan Damian Sirbu]

Greetings,

I have a problem with finding a regex pattern that should match any text containing a group of letters, and in the same time it does not contain another group of letters.
Iterating a file line by line, I need to extract the lines containing the word 'input', AND not containing the word 'type'.
So, 'input damian whatever' is a match, while 'input damian type whatever' is not.

Any ideas?

[Vivek Singh]

So why Regular expression is required?
As you know the exact text which you need so try this.

String line ="input damian whatever";
	    System.out.println(line.contains("input"));    

[Ioan Damian Sirbu]

I was giving an arbitrary example.
The concrete situation is:
- I need to make a search in Eclipse in all files.
- I need to find the files that contain a custom tag that is like this <input type="calendar"> but is not like <input type="calendar" theme="simple">

I think that using Eclipse's regex matches are an option, and in the same time this regex dilemma is interesting by itself

[Ioan Damian Sirbu]

So, any ideas?

[Jeanne Boyarsky]

Damian Sarbu wrote:So, any ideas?

Yes. Negative lookahead/lookbehind.

It checks for the lack of presence of a regular expression after or before the one you are interested in.

[Ioan Damian Sirbu]

Thank you, I actually found a good tutorial right here http://www.javaranch.com/journal/2003/04/RegexTutorial.htm
For whoever is interested, the regex should look like this
((.*calendar.*)(?! .*simple.*))

[Ireneusz Kordal]

Damian Sarbu wrote:For whoever is interested, the regex should look like this
((.*calendar.*)(?! .*simple.*))

Maybe this pattern works in eclipse, but in java it doesn't work as you expect:

       System.out.println("calendar ".matches("((.*calendar.*)(?!.*simple.*))"));
       System.out.println("simple ".matches("((.*calendar.*)(?!.*simple.*))"));
       System.out.println("calendar simple ".matches("((.*calendar.*)(?!.*simple.*))"));
       System.out.println("simple calendar".matches("((.*calendar.*)(?!.*simple.*))"));

Results:
true
false
true
true

[Rob Spoor]

Using .* or similar non-deterministic regex sequences inside lookaheads and lookbehinds usually doesn't do what you want.

[Ioan Damian Sirbu]

No, it was my fault.. I posted wrong.
By matching (.*document.*), I was capturing the whole expression. If the input was "calendar simple", the
lookahead (.*simple.*) would have nothing left to match.
The correct pattern would be (calendar)(?!.*simple.*). This would return true for "calendar" or 'calendar some words", but false for "calendar simple".

I tested this with the RegexTestHarness in the Sun tutorials.

Enter your regex: (calendar)(?!.*simple.*)
Enter input string to search: calendar
I found the text "calendar" starting at index 0 and ending at index 8.

Enter your regex: (calendar)(?!.*simple.*)
Enter input string to search: calendar whatever
I found the text "calendar" starting at index 0 and ending at index 8.

Enter your regex: (calendar)(?!.*simple.*)
Enter input string to search: calendar simple
No match found.

Enter your regex: (calendar)(?!.*simple.*)
Enter input string to search: simple
No match found.

PS: Now that I think I got how this works, I am trying to combine lookahead with lookbehind