How to match the first word after an expression with regex?

Question

For example, in this text:

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc eu tellus vel nunc pretium lacinia. Proin sed lorem. Cras sed

Answer 1

ipsum\b(.*)\b

EDIT: although depending on your regex implementation, this could be hungry and find all words after ipsum

Answer 2

Some of the other responders have suggested using a regex that doesn't depend on lookbehinds, but I think a complete, working example is needed to get the point across. The idea is that you match the whole sequence ("ipsum" plus the next word) in the normal way, then use a capturing group to isolate the part that interests you. For example:

String s = "Lorem ipsum dolor sit amet, consectetur " +
    "adipiscing elit. Nunc eu tellus vel nunc pretium " +
    "lacinia. Proin sed lorem. Cras sed ipsum. Nunc " +
    "a libero quis risus sollicitudin imperdiet.";

Pattern p = Pattern.compile("ipsum\\W+(\\w+)");
Matcher m = p.matcher(s);
while (m.find())
{
  System.out.println(m.group(1));
}

Note that this prints both "dolor" and "Nunc". To do that with the lookbehind version, you would have to do something hackish like:

Pattern p = Pattern.compile("(?<=ipsum\\W{1,2})(\\w+)");

That's in Java, which requires the lookbehind to have an obvious maximum length. Some flavors don't have even that much flexibility, and of course, some don't support lookbehinds at all.

However, the biggest problem people seem to be having in their examples is not with lookbehinds, but with word boundaries. Both David Kemp and ck seem to expect \b to match the space character following the 'm', but it doesn't; it matches the position (or boundary) between the 'm' and the space.

It's a common mistake, one I've even seen repeated in a few books and tutorials, but the word-boundary construct, \b, never matches any characters. It's a zero-width assertion, like lookarounds and anchors (^, $, \z, etc.), and what it matches is a position that is either preceded by a word character and not followed by one, or followed by a word character and not preceded by one.

Answer 3

With javascript you can use (?=ipsum.*?(\w+))

This will get the second occurrence as well (Nunc)

Answer 4

(?<=\bipsum\s|\bipsum\.\s)(\w+)

/(?<=\bipsum\s|\bipsum\.\s)(\w+)/gm Positive Lookbehind (?<=\bipsum\s|\bipsum\.\s) Assert that the Regex below matches

1. 1st Alternative \bipsum\s \b assert position at a word boundary: (^\w|\w$|\W\w|\w\W) ipsum matches the characters ipsum literally (case sensitive) \s matches any whitespace character (equal to [\r\n\t\f\v ])
2. 2nd Alternative \bipsum\.\s \b assert position at a word boundary: (^\w|\w$|\W\w|\w\W) ipsum matches the characters ipsum literally (case sensitive) . matches the character . literally (case sensitive) \s matches any whitespace character (equal to [\r\n\t\f\v ]) 1st Capturing Group (\w+) \w+ matches any word character (equal to [a-zA-Z0-9_])

• Quantifier — Matches between one and unlimited times, as many times as possible, giving back as needed (greedy) Global pattern flags g modifier: global. All matches (don't return after first match) m modifier: multi line. Causes ^ and $ to match the begin/end of each line (not only begin/end of string)

Answer 5

This sounds like a job for lookbehinds, though you should be aware that not all regex flavors support them. In your example:

(?<=\bipsum\s)(\w+)

This will match any sequence of letter characters which follows "ipsum" as a whole word followed by a space. It does not match "ipsum" itself, you don't need to worry about reinserting it in the case of, e.g. replacements.

As I said, though, some flavors (JavaScript, for example) don't support lookbehind at all. Many others (most, in fact) only support "fixed width" lookbehinds — so you could use this example but not any of the repetition operators. (In other words, (?<=\b\w+\s+)(\w+) wouldn't work.)

Answer 6

ipsum\b(\w*)