Skip to main content

Regular Expression

About​

A list of useful regular expression examples.Regular Expressions are used throughout FreeSWITCH. See Dialplan_XML for complete examples of the regular expressions used in conditional statements in the dialplan.

Click here to expand Table of Contents

Capturing Values​

Matching items in parentheses are captured in variables sequentially named $1, $2, etc. $0 contains the entire pattern.

Examples​

Any toll free Number​

Matches any toll free number

^(\+?1)?(8(00|44|55|66|77|88)[2-9]\d{6})$

Example: 8005551212 or 18005551212 or +18005551212 will match and in each case $2 is populated with "8005551212"

Explanation:

  • ^ - indicates the beginning of a regular expression (required);
  • ( - indicates the beginning of a regular expression block - blocks are important to define inner expressions so they can be referenced by the variables $1, $2, $3, etc;
  • \+1|1? - indicates optional digits '+1' or '1' (the ? sign defines the literal as optional);
  • ) - closes the block;
  • 8 - matches the literal '8';
  • ( - another block starting;
  • 00|55|66|77|88 - matches 00 or 55 or 66 or 77 or 88 (you guessed right, the | sign is the OR operator);
  • ) - closes the inner block;
  • [2-9] - matches one digit in the range from 2 to 9 (2, 3, 4, 5, 6, 7, 8 and 9), and as you also guessed the [] pair of brackets encloses a range; other range examples: [0-9] matches 0 to 9; [a-z] matches a, b, c, ...z);
  • \d - matches any valid digit (same as [0-9]);
  • {6} - defines the number of occurrences for the previous expression, i.e. exactly 6 digits in the range 0-9. This can also contain a variable number of occurrences, for example to match a sequence of 6 to 9 digits: {6,9}; or to match at least 6 with no maximum: {6,};
  • ) - closes the other block;
  • $ - indicates the end of the regular expression (required);

Any string of exactly seven digits​

Matches any string of exactly seven digits

^(\d{7})$
Example: 5551212 will match with $1 having "5551212"
         95551212 will not match (string of digits too long)
         555121A will not match (no alpha chars allowed)

Any string of exactly 10 digits​

Matches any string of exactly 10 digits

^(\d{10})$
Example: 8005551212 will match with $1 having "8005551212"
         18005551212 will not match (string of digits too long)

Any string of exactly 11 digits​

Matches any string of exactly 11 digits

^(\d{11})$
Example: 18005551212 will match with $1 having "18005551212"
         8005551212 will not match (string of digits too short) 

A string with prefix of 9 and an additional 11 digits​

Matches a string with a prefix of 9 and an additional 11 digits.

^9(\d{11})$
Example: 918005551212 will match with $1 having "18005551212"
         8005551212 will not match (string of digits too short)

Any string of exactly 3 or 4 digits​

Matches any string of exactly 3 or 4 digits

(^\d{4}$|^\d{3}$)
Example: 1001 will match with $1 having "1001"
         102 will match with $1 having "102"
         *9999 will not match
         *98 will not match

Any string from 3 to 5 digits​

Matches any string from 3 to 5 digits

(^\d{3,5}$)
Example: 10010 will match with $1 having "10010"
         102 will match with $1 having "102"
         *9999 will not match
         *98 will not match

Variable number of digits​

Matches a variable number of digits after a prefix of '9'

^9(\d+)$
Example: 977 will match ($1 = 77)
         877 will not match
         966736 will match ($1 = 66736)
         9118299983 will match ($1 = 118299983)
         9 will not match (+ means one or more)

International country codes​

  <extension name="international" continue="true">
    <!--
            ^\+(1|  # NANPA
       2[1-689]\d|  # 21X,22X,23X,24X,25X,26X,28X,29X
            2[07]|  # 20, 27
         3[0-469]|  # 30,31,32,33,34,36,39
         3[578]\d|  # 35X,37X,38X
        4[0-13-9]|  # 40,41,43,44,45,46,47,48,49
             42\d|  # 42X
          5[09]\d|  # 50X, 59X
           5[1-8]|  # 51,52,53,54,55,56,57,58
           6[0-6]|  # 60,61,62,63,64,65,66
         6[7-9]\d|  # 67X,68X,69X
                7|
      8[035789]\d|  # 80X,83X,85X,87X,88X,89X
          8[1246]|  # 81,82,84,86
          9[0-58]|  # 90,91,92,93,94,95,98
         9[679]\d   # 96X,97X,99X
                )(\d+)
    -->
    <condition field="destination_number" expression="^\+(1|2[1-689]\d|2[07]|3[0-469]|3[578]\d|4[0-13-9]|42\d|5[09]\d|5[1-8]|6[0-6]|6[7-9]\d|7|8[035789]\d|8[1246]|9[0-58]|9[679]\d)(\d+)">
     <action application="set" data="country_code=$1"/>
     <action application="set" data="national_number=$2"/>
    </condition>
  </extension>

NANPA +1NxxNxxXXXX E.164 Dialstring​

^(\+1|1)?([2-9]\d\d[2-9]\d{6})$
Example: +13172222222 matches
         13172222222 still matches because +1 or 1 are optional
         3172222222 still matches because +1 or 1 are optional
         3171222222 does not match and is not a valid NANPA number.

LNP (Local Number Portability)​

^(?:1)?([2-9]\d{2}[2-9]\d{6})(?:;npdi=(?:yes|no))?(?:;rn=([2-9]\d{2}[2-9]\d{6}))?(?:;npdi=(?:yes|no))?

Example:

6045555555;npdi=yes;rn=7785550001
6045555555;rn=7785550001;npdi=yes
16045555555;npdi=yes;rn=7785550001
6045555555;rn=7785550001
Result:
$1=6045555555
$2=7785550001

Example:

6045555555
16045555555
6045555555;npdi=yes
6045555555;npdi=no
Result:
$1=6045555555
$2=empty

Clustering vs Capturing​

Sometimes, you need to use parentheses to group a set of choices, but you are not interested in saving what is matched. Place a question mark and colon after the opening parenthesis to accomplish this. The example below matches a leading "+" or leading "00", but the matched information is not saved. The second set of parentheses does save information that is matched.

^(?:\+|00)(\d+)$
Example: +13171222222 matches and captures 13171222222 in $1
         0013171222222 matches and captures 13171222222 in $1

The following example matches a number and saves the information in two pieces as leading characters ($1) and the telephone number ($2).

^(\+|00)(\d+)$
Example: +13171222222 matches and captures + in $1 and 13171222222 in $2
         0013171222222 matches and captures 00 in $1 and 13171222222 in $2

Parentheses can be nested. When trying to determine which variable holds the matched information, count the opening parentheses from left to right. The first opening parenthesis will store information in $1, the second opening parenthesis will store information in $2 and so on.

^((\+|00)(\d+))$
Example: +13171222222 matches and captures +13171222222 in $1, + in $2 and 13171222222 in $3
         0013171222222 matches and captures 0013171222222 in $1, 00 in $2 and 13171222222 in $3

In the following example, the first set of parentheses does not store any information.

^(?:(\+|00)(\d+))$
Example: +13171222222 matches and captures + in $1 and 13171222222 in $2
         0013171222222 matches and captures 00 in $1 and 13171222222 in $2

Greediness​

^rn=(.*);
Example: rn=1234567890;npdi; matches and captures 1234567890;npdi in $1

If you do .*? it will be un-greedy (or use \d to only match the numbers if you know it will be a number)

^rn=(.*?);
Example: rn=1234567890;npdi; matches and captures 1234567890 in $1

Case Insensitive​

To make a match case insensitive, prepend (?i) to your match string.

Example: (?i)restricted matches both Restricted and restricted

Further Reading​

Regular Expressions are serious business. They are quite useful in computing in general. Here are some other resources for learning more:
http://regexlib.com/Default.aspx
http://www.regular-expressions.info/
http://www.weitz.de/regex-coach/
http://regexlib.com/CheatSheet.aspx
http://www.zytrax.com/tech/web/regex.htm
http://oreilly.com/catalog/9781565922570/
http://perldoc.perl.org/perlreref.html

Test Your Regex​

Use fs_cli​

See: mod_commands#regex

Online Tools​

Simple Perl Script​

You can also use the following perl script to test your regular expression, or make some adjustment of regex based on what you need.

#!/usr/bin/perl
$x=$ARGV[0];
if($x=~/^(\+1|1)?([2-9]\d\d[2-9]\d{6})$/)
{
       print "Input: $x\n";
       print "\$1 Output: ".$1."\n";
       print "\$2 Output: ".$2."\n";
}

Result:

# perl x.pl 12135551212
Input: 12135551212
$1 Output: 1
$2 Output: 2135551212
# perl x.pl +12135551212
Input: +12135551212
$1 Output: +1
$2 Output: 2135551212
# perl x.pl 2135551212  
Input: 2135551212
$1 Output: 
$2 Output: 2135551212

See Also​

regex API command performs pattern matching on the fs_cli

Regular Expression Cheat Sheet: http://overapi.com/regex/