Programming

Lookaround Operators

Lookaround operators have two components: a match pattern and a test pattern. If you call the match pattern p₁ and the test pattern p₂, then the simplest form of lookaround operator looks like this:

• p1(?=p2)
  

The match pattern p₁ is just like any other element in an expression. For example, it can be '\<[A-Za-z]+\>' to make regexp find any word.

The test pattern p₂ places a condition on this match. There can be a match for p₁ only if there is also a match for p₂, and the p₂ match must immediately precede (for lookbehind operators) or follow (for lookahead operators) the match for p₁.

In the following expression, the match pattern is '\<[A-Za-z]+\>' and the test pattern is '\S'. The entire expression can be read as "Find those words that are followed by a non-white-space character":

• '\<[A-Za-z]+\>(?=\S)'
  

When used on the following string, this lookahead expression matches the letters of the words Raven and Nevermore:

• str = 'Quoth the Raven, "Nevermore"';
  
  regexp(str, '\<[A-Za-z]+\>(?=\S)', 'match')
  ans = 
      'Raven'    'Nevermore'
  

One important characteristic of lookaround operators is how they affect the parsing of the input string. The parser can be said to "consume" pieces of the string as it looks for matching phrases. With lookaround operators, only the match pattern p₁ affects the current parsing location. Finding a match for the test pattern p₂ does not move the parser location.

Note    You can also use lookaround operators to perform a logical AND of two elements. See Using Lookaround as a Logical Operator.

This table shows the four lookaround expressions: lookahead, negative lookahead, lookbehind, and negative lookbehind.

Operator	Usage
expr1(?=expr2)	Match expression expr1 if followed by expression expr2.
expr1(?!expr2)	Match expression expr1 if not followed by expression expr2.
(?<=expr1)expr2	Match expression expr2 if preceded by expression expr1.
(?<!expr1)expr2	Match expression expr2 if not preceded by expression expr1.

Lookahead -- expr1(?=expr2)

Use p₁(?=p₂) to find all words of this string that precede a comma:

• poestr = ['While I nodded, nearly napping, ' ...
            'suddenly there came a tapping,'];
  
  [mat idx] = regexp(poestr, '\w*(?=,)', 'match', 'start')
  mat = 
      'nodded'    'napping'    'tapping'
  idx =
       9    24    55
  

Negative Lookahead -- expr1(?!expr2)

Use p₁(?!p₂) to find all words that do not precede a comma:

• [mat idx] = regexp(poestr, '\w+(?!\w*,)', 'match', 'start')
  mat = 
      'While'  'I'  'nearly'  'suddenly'  'there'  'came'  'a'
  idx =
       1     7    17    33    42    48    53
  

Lookbehind -- (?<=expr1)expr2

Use (?<=p₁)p₂ to find all words that follow a comma and zero or more spaces:

• [mat idx] = regexp(poestr, '(?<=,\s*)\w*', 'match', 'start')
  mat = 
      'nearly'    'suddenly'
  idx =
      17    33
  

Negative Lookbehind -- (?<!expr1)expr2

Use (?<!p₁)p₂ to find all words that do not follow a comma and zero or more spaces:

• [mat idx] = regexp(poestr, '(?<!,\s*\w*)\w*', 'match', 'start')
  mat = 
     'While' 'I' 'nodded' 'napping' 'there' 'came' 'a' 'tapping'
  idx =
       1     7     9    24    42    48    53    55
  

Using Lookaround as a Logical Operator

You can use lookaround operators to perform a logical AND, as shown in this example. The expression used here finds all words that contain a sequence of two letters under the condition that the two letters are identical and are in the range a through m. (The expression '(?=[a-m])' is a lookahead test for the range a through m, and the expression '(.)\1' tests for identical characters using a token):

• [mat idx] = regexp(poestr, '\<\w*(?=[a-m])(.)\1\w*\>', ...
     'match', 'start')
  mat = 
      'nodded'    'suddenly'
  idx =
       9    33
  

Note that when using a lookahead operator to perform an AND, you need to place the match expression expr₁ after the test expression expr₂:

• (?=expr2)expr1           or         (?!expr2)expr1
  

Logical Operators

Quantifiers

© 1994-2005 The MathWorks, Inc.