regexp - Match regular expression (case sensitive)

Syntax

Description

regexp(string,expr) parses the input string locating those parts of string that match the character pattern(s) specified by regular expression, expr. This syntax returns the starting index of each match. If no matches are found, regexp returns an empty array.

[matchstart,matchend,tokenindices,matchstring,tokenstring,tokenname,splitstring] = regexp(string,expr) returns from one to seven output values, depending on the number of output variables you specify.

[selected_outputs] = regexp(string,expr,outselect) returns from one to seven output values, depending on which flags you specify in outselect. The presence and ordering of the outselect inputs determine the presence and ordering of the corresponding outputs.

regexp(string,expr,options) calls regexp with one or more of the nondefault options listed in the Command Options table, below. These options must follow the string and expr inputs in the argument list.

Tips

• For more information on this and other regular expression functions, see Regular Expressions in the MATLAB Programming Fundamentals documentation.

• The string and expr inputs are required. Enter these as the first and second arguments, respectively. Any other input arguments are optional. Enter optional inputs, in any order, following the two required inputs.

Input Arguments

Output Arguments

Each of the first seven outputs listed below is returned as a 1-by-m array, where m is the number of matches found by regexp.

When parsing multiple strings (i.e., a 1-by-n or n-by-1 cell array of strings), regexp returns a 1-by-n cell array for each output specified. When parsing an m-by-n cell array of strings, regexp returns an m-by-n cell array for each output specified.

[index, matstr] = regexp('Jan 24','\d',...
'start','match')

Examples

Return a row vector of indices that match words that start with c, end with t, and contain one or more vowels between them. Make the matches sensitive to letter case (by using the case-sensitive regexp):

str = 'bat cat can car COAT court cut ct CAT-scan';
regexp(str, 'c[aeiou]+t')
ans =
     5    28

Return a cell array of row vectors of indices that match capital letters and white spaces in the cell array of strings str:

str = {'Madrid, Spain' 'Romeo and Juliet' 'MATLAB is great'};
s1 = regexp(str, '[A-Z]');
s2 = regexp(str, '\s');

Capital letters, '[A-Z]', were found at these str indices:

s1{:}
ans =
     1     9
ans =
     1    11
ans =
     1     2     3     4     5     6

Space characters, '\s', were found at these str indices:

s2{:}
ans =
     8
ans =
     6    10
ans =
     7    10

Return the text and the starting and ending indices of words containing the letter x:

str = 'REGEXP helps you relax';
[m s e] = regexp(str, '\w*x\w*', 'match', 'start', 'end')
m = 
    'relax'
s =
     18
e =
     22

Find the substrings delimited by the ^ character:

s1 = ['Use REGEXP to split ^this string into ' ...
      'several ^individual pieces'];

s2 = regexp(s1, '\^', 'split');

s2(:)
ans = 
    'Use REGEXP to split '
    'this string into several '
    'individual pieces'

Use the 'split' keyword to return those parts of the input string that are not returned when using 'match'. Note that when you match the beginning or ending characters in a string (as is done in this example), the first (or last) return value is always an empty string:

str = 'She sells sea shells by the seashore.';

[matchstr splitstr] = regexp(str, '[Ss]h.', 'match', ...
                             'split')
matchstr = 
    'She'    'she'    'sho'
splitstr = 
     ''    ' sells sea '    'lls by the sea'    're.'

For any string that has been split, you can reassemble the pieces into the initial string using the command

j = [splitstr; [matchstr {''}]]; [j{:}]

ans =
   She sells sea shells by the seashore.

Search a string for opening and closing HTML tags. Use the expression <(\w+) to find the opening tag (for example, '<tagname') and to create a token for it. Use the expression </\1> to find another occurrence of the same token, but formatted as a closing tag (for example, '</tagname>'):

str = ['if <code>A</code> == x<sup>2</sup>, ' ...
       '<em>disp(x)</em>']
str =
if <code>A</code> == x<sup>2</sup>, <em>disp(x)</em>

expr = '<(\w+).*?>.*?</\1>';

[tok mat] = regexp(str, expr, 'tokens', 'match');

tok{:}
ans = 
    'code'
ans = 
    'sup'
ans = 
    'em'

mat{:}
ans =
    <code>A</code>
ans =
    <sup>2</sup>
ans =
    <em>disp(x)</em>

For information on using tokens, see Tokens in the MATLAB Programming Fundamentals documentation.

1. Enter a string containing two names, the first and last names being in a different order:

   str = sprintf('John Davis\nRogers, James')
   str =
       John Davis
       Rogers, James

2. Create an expression that generates first and last name tokens, assigning the names first and last to the tokens. Call regexp to get the text and names of each token found:

   expr = ...
      '(?<first>\w+)\s+(?<last>\w+)|(?<last>\w+),\s+(?<first>\w+)';
   
   [tokens names] = regexp(str, expr, 'tokens', 'names');

3. Examine the tokens cell array that was returned. The first and last name tokens appear in the order in which they were generated: first name–last name, then last name–first name:

   tokens{:}
   ans = 
       'John'    'Davis'
   ans = 
       'Rogers'    'James'

4. Now examine the names structure that was returned. First and last names appear in a more usable order:

   names(:,1)
   ans = 
       first: 'John'
        last: 'Davis'
   
   names(:,2)
   ans = 
       first: 'James'
        last: 'Rogers'

Use Case Sensitivity mode with regexp.

1. Given a string that has both uppercase and lowercase letters, use the regexp default mode (case-sensitive) to locate only the lowercase instance of the word case:

   str = 'A string with UPPERCASE and lowercase text.';
   
   regexp(str, 'case', 'match')
   ans = 
       'case'

2. Now disable case-sensitive matching to find both instances of case:

   regexp(str, 'case', 'ignorecase', 'match')
   ans = 
       'CASE'    'case'

3. Match 5 letters that are followed by 'CASE'. Use the (?-i) flag to turn off case insensitivity for the first match and (?i) to turn insensitivity on for the second:

   M = regexp(str, {'(?-i)\w{5}(?=CASE)', ...
                    '(?i)\w{5}(?=CASE)'}, 'match');
   
   M{:}
   ans = 
       'UPPER'
   ans = 
       'UPPER'    'lower'

Use Empty Match mode with regexp to add the characters '=> 'to the beginning of each line in the following text:

text = {'Use the REGEXPREP function in '; ...
  'Empty Match mode to insert a right '; ...
  'arrow at the start of each line.'};

newtext = regexprep(text, '^', '=> ', 'emptymatch')

newtext =
'=> Use the REGEXPREP function in '
'=> Empty Match mode to insert a right '
'=> arrow at the start of each line.'

The ^ operator matches the beginning of each string. Because there are no other characters to match, and the emptymatch mode is enabled by the fifth input argument of the command, there is an empty match at the beginning of each string.

1. Search the string 'MATLAB' for zero or more of the characters M, A, and T. Do not include matches of zero-length. (The mode defaults to noemptymatch):

   regexp('MATLAB', '[MAT]*', 'match')	
   ans = 
       'MAT'    'A'

2. Repeat this search, but this time specify emptymatch mode to include matches of zero-length.

   Note   Note that there is also a match for the position that follows the final character.

   regexp('MATLAB', '[MAT]*', 'emptymatch', 'match')
   ans = 
       'MAT'    ''    'A'    ''    ''
   

3. Now, use the + (one or more) operator instead of the * (zero or more) operator. Continue to use emptymatch mode:

   regexp('MATLAB', '[MAT]+', 'emptymatch', 'match')
   ans = 
       'MAT'    'A'

   No match is found for the L and B characters this time because regexp needs to find a least one occurrence of these characters for a match to be found.

Use Dot Matching mode with regexp to parse the following string, which contains a newline (\n) character:

str = sprintf('abc\ndef')
str =
   abc
   def

When you use the default mode, dotall, MATLAB includes the newline in the characters matched:

regexp(str, '.', 'match')
ans = 
   'a'   'b'   'c'   [1x1 char]   'd'   'e'   'f'

When you use the dotexceptnewline mode, MATLAB skips the newline character:

regexp(str, '.', 'match', 'dotexceptnewline')
ans = 
   'a'   'b'   'c'   'd'   'e'   'f'

Use Anchor Type mode with regexp to control whether you parse a multiline string line by line, or once for the entire string. Use the following two-line string:

str = sprintf('%s\n%s', 'Here is the first line', ...
              'followed by the second line')
str =
   Here is the first line
   followed by the second line

In stringanchors mode, MATLAB interprets the $ metacharacter as an end-of-string specifier, and thus finds the last two words of the entire string:

regexp(str, '\w+\W\w+$', 'match', 'stringanchors')
ans = 
    'second line'

While in lineanchors mode, MATLAB interprets $ as an end-of-line specifier, and finds the last two words of each line:

regexp(str, '\w+\W\w+$', 'match', 'lineanchors')
ans = 
    'first line'    'second line'

Use Spacing mode with regexp to read a regular expression from a file, retrieving all operators and metacharacters from the file, but skipping any comment text:

1. Create a file called regexp_str.txt containing the following text.

   (?x)    # turn on freespacing.
   
   # This pattern matches a string with a repeated letter.
   
   \w*     # First, match any number of preceding word characters.
       
   (       # Mark a token.
   .       # Match a character of any type.
   )       # Finish capturing said token.
   \1      # Backreference to match what token #1 matched.
   
   \w*     # Finally, match the remainder of the word.

2. Use the pattern expression read from the file to find those words that have consecutive matching letters. Because the first line enables freespacing mode, MATLAB ignores all spaces and comments that appear in the file:

   str = ['Looking for words with letters that ' ...
          'appear twice in succession.'];
   patt = fileread('regexp_str.txt');
   
   regexp(str, patt, 'match')
   ans = 
       'Looking'    'letters'    'appear'    'succession'

Debug problems in parsing a string with regexp, regexpi, or regexprep, using the 'warnings' option to view all warning messages:

regexp('$.', '[a-]','warnings')
Warning: Unbound range.
 [a-]
   | 

See Also

regexpi | regexprep | regexptranslate | strcmp | strcmpi | strfind | strncmp | strncmpi

How To

• Regular Expressions

Free MATLAB Interactive Kit

Explore how to use MATLAB to make advancements in engineering and science.

Download free kit

Trials Available

Try the latest version of MATLAB and other MathWorks products.

Get trial software