Top Level

# RegExp - AS3

Package | Top Level
Class | public dynamic class RegExp
Inheritance | RegExp Object

Language Version: | ActionScript 3.0

Runtime Versions: | AIR 1.0, Flash Player 9, Flash Lite 4

The RegExp class lets you work with regular expressions, which are patterns that you can use to perform searches in strings and to replace text in strings.

You can create a new RegExp object by using the `new RegExp()` constructor or by assigning a RegExp literal to a variable:

Copy

     var pattern1:RegExp = new RegExp("test-\\d", "i");
         var pattern2:RegExp = /test-\d/i;

For more information, see "Using Regular Expressions" in the ActionScript 3.0 Developer's Guide.

View the examples

More examples

Regular expression syntax

Related API Elements

String.match()
String.replace()
String.search()

Public Properties
Hide Inherited Public Properties
Show Inherited Public Properties

| Property | Defined By
--- | --- | ---
|  | constructor : Object A reference to the class object or constructor function for a given object instance. | Object
|  | dotall : Boolean [read-only] Specifies whether the dot character (.) in a regular expression pattern matches new-line characters. | RegExp
|  | extended : Boolean [read-only] Specifies whether to use extended mode for the regular expression. | RegExp
|  | global : Boolean [read-only] Specifies whether to use global matching for the regular expression. | RegExp
|  | ignoreCase : Boolean [read-only] Specifies whether the regular expression ignores case sensitivity. | RegExp
|  | lastIndex : Number Specifies the index position in the string at which to start the next search. | RegExp
|  | multiline : Boolean [read-only] Specifies whether the m (multiline) flag is set. | RegExp
|  | source : String [read-only] Specifies the pattern portion of the regular expression. | RegExp

Public Methods
Hide Inherited Public Methods
Show Inherited Public Methods

| Method | Defined By
--- | --- | ---
|  | RegExp(re:String, flags:String) Lets you construct a regular expression from two strings. | RegExp
|  | exec(str:String):Object Performs a search for the regular expression on the given string str. | RegExp
|  | hasOwnProperty(name:String):Boolean Indicates whether an object has a specified property defined. | Object
|  | isPrototypeOf(theClass:Object):Boolean Indicates whether an instance of the Object class is in the prototype chain of the object specified as the parameter. | Object
|  | propertyIsEnumerable(name:String):Boolean Indicates whether the specified property exists and is enumerable. | Object
|  | setPropertyIsEnumerable(name:String, isEnum:Boolean = true):void Sets the availability of a dynamic property for loop operations. | Object
|  | test(str:String):Boolean Tests for the match of the regular expression in the given string str. | RegExp
|  | toLocaleString():String Returns the string representation of this object, formatted according to locale-specific conventions. | Object
|  | toString():String Returns the string representation of the specified object. | Object
|  | valueOf():Object Returns the primitive value of the specified object. | Object

Property Detail

### dotall

property

`dotall:Boolean` [read-only]

Language Version: | ActionScript 3.0

Runtime Versions: | AIR 1.0, Flash Player 9, Flash Lite 4

Specifies whether the dot character (.) in a regular expression pattern matches new-line characters. Use the `s` flag when constructing a regular expression to set `dotall = true`.

Implementation
`public function get dotall():Boolean`

More examples

Regular expression syntax
Flags and properties
Example ( How to use this example )
The following example shows the effect of the `s` (`dotall`) flag on a regular expression:
Copy

    var str:String = "<p>Hello\n"
            + "again</p>"
            + "<p>Hello</p>";

    var pattern:RegExp = /<p>.*?<\/p>/;
    trace(pattern.dotall) // false
    trace(pattern.exec(str)); // <p>Hello</p>

    pattern = /<p>.*?<\/p>/s;
    trace(pattern.dotall) // true
    trace(pattern.exec(str));

### extended

property

`extended:Boolean` [read-only]

Language Version: | ActionScript 3.0

Runtime Versions: | AIR 1.0, Flash Player 9, Flash Lite 4

Specifies whether to use extended mode for the regular expression. When a RegExp object is in extended mode, white space characters in the constructor string are ignored. This is done to allow more readable constructors.

Use the `x` flag when constructing a regular expression to set `extended = true`.

Implementation
`public function get extended():Boolean`

More examples

Regular expression syntax
Flags and properties
Example ( How to use this example )
The following example shows different ways to construct the same regular expression. In each, the regular expression is to match a phone number pattern of xxx-xxx-xxxx or (xxx) xxx-xxxx or (xxx)xxx-xxxx. The second regular expression uses the `x` flag, causing the white spaces in the string to be ignored.
Copy

    var rePhonePattern1:RegExp = /\d{3}-\d{3}-\d{4}|\(\d{3}\)\s?\d{3}-\d{4}/;
    var str:String = "The phone number is (415)555-1212.";

    trace(rePhonePattern1.extended) // false
    trace(rePhonePattern1.exec(str)); // (415)555-1212

    var rePhonePattern2:RegExp = / \d{3}-\d{3}-\d{4}  |   \( \d{3} \) \ ? \d{3}-\d{4}  /x;
    trace(rePhonePattern2.extended) // true
    trace(rePhonePattern2.exec(str)); // (415)555-1212

### global

property

`global:Boolean` [read-only]

Language Version: | ActionScript 3.0

Runtime Versions: | AIR 1.0, Flash Player 9, Flash Lite 4

Specifies whether to use global matching for the regular expression. When `global == true`, the `lastIndex` property is set after a match is found. The next time a match is requested, the regular expression engine starts from the `lastIndex` position in the string. Use the `g` flag when constructing a regular expression to set `global` to `true`.

Implementation
`public function get global():Boolean`

More examples

Regular expression syntax
Flags and properties
Example ( How to use this example )
The following example shows the effect setting the `g` (`global`) flag on the `exec()` method:
Copy

    var pattern:RegExp = /foo\d/;
    var str:String = "foo1 foo2";
    trace(pattern.global); // false
    trace(pattern.exec(str)); // foo1
    trace(pattern.lastIndex); // 0
    trace(pattern.exec(str)); // foo1

    pattern = /foo\d/g;
    trace(pattern.global); // true
    trace(pattern.exec(str)); // foo1
    trace(pattern.lastIndex); // 4
    trace(pattern.exec(str)); // foo2

### ignoreCase

property

`ignoreCase:Boolean` [read-only]

Language Version: | ActionScript 3.0

Runtime Versions: | AIR 1.0, Flash Player 9

Specifies whether the regular expression ignores case sensitivity. Use the `i` flag when constructing a regular expression to set `ignoreCase = true`.

Implementation
`public function get ignoreCase():Boolean`

More examples

Regular expression syntax
Flags and properties
Example ( How to use this example )
The following example shows the effect of setting the `i` (`ignoreCase`) flag:
Copy

    var pattern:RegExp = /bob/;
    var str:String = "Bob bob";
    trace(pattern.ignoreCase); // false
    trace(pattern.exec(str)); // bob

    pattern = /bob/i;
    trace(pattern.ignoreCase); // true
    trace(pattern.exec(str)); // Bob

### lastIndex

property

`lastIndex:Number`

Language Version: | ActionScript 3.0

Runtime Versions: | AIR 1.0, Flash Player 9, Flash Lite 4

Specifies the index position in the string at which to start the next search. This property affects the `exec()` and `test()` methods of the RegExp class. However, the `match()`, `replace()`, and `search()` methods of the String class ignore the `lastIndex` property and start all searches from the beginning of the string.

When the `exec()` or `test()` method finds a match and the `g` (`global`) flag is set to `true` for the regular expression, the method automatically sets the `lastIndex` property to the index position of the character after the last character in the matching substring of the last match. If the `g` (`global`) flag is set to `false`, the method does not set the `lastIndex`property.

You can set the `lastIndex` property to adjust the starting position in the string for regular expression matching.

Implementation
`public function get lastIndex():Number`
`public function set lastIndex(value:Number):void`

More examples

Regular expression syntax
Flags and properties
Example ( How to use this example )
The following example shows the effect of setting the `lastIndex` property, and it shows how it is updated after a call to the `exec()` method on a regular expression in which the `g` (`global`) flag is set:
Copy

    var pattern:RegExp = /\w\d/g;
    var str:String = "a1 b2 c3 d4";
    pattern.lastIndex = 2;
    trace(pattern.exec(str)); // b2
    trace(pattern.lastIndex); // 5
    trace(pattern.exec(str)); // c3
    trace(pattern.lastIndex); // 8
    trace(pattern.exec(str)); // d4
    trace(pattern.lastIndex); // 11
    trace(pattern.exec(str)); // null

### multiline

property

`multiline:Boolean` [read-only]

Language Version: | ActionScript 3.0

Runtime Versions: | AIR 1.0, Flash Player 9, Flash Lite 4

Specifies whether the `m` (`multiline`) flag is set. If it is set, the caret (`^`) and dollar sign (`$`) in a regular expression match before and after new lines. Use the `m` flag when constructing a regular expression to set `multiline = true`.

Implementation
`public function get multiline():Boolean`

More examples

Regular expression syntax
Flags and properties
Example ( How to use this example )
The following example shows the effect setting the `m` (`multiline`) flag:
Copy

    var pattern:RegExp = /^bob/;
    var str:String = "foo\n"
                    + "bob";
    trace(pattern.multiline); // false
    trace(pattern.exec(str)); // null

    pattern = /^bob/m;
    trace(pattern.multiline); // true
    trace(pattern.exec(str)); // bob

### source

property

`source:String` [read-only]

Language Version: | ActionScript 3.0

Runtime Versions: | AIR 1.0, Flash Player 9, Flash Lite 4

Specifies the pattern portion of the regular expression.

Implementation
`public function get source():String`

More examples

Regular expression syntax
Flags and properties
Example ( How to use this example )
The following code outputs the `source` parameter for two regular expressions:
Copy

    var re1:RegExp = /aabb/gi;
    trace (re1.source); // aabb

    var re2:RegExp = new RegExp("x+y*", "i");
    trace(re2.source); // x+y*

Constructor Detail

### RegExp

()
Constructor

`public function RegExp(re:String, flags:String)`

Language Version: | ActionScript 3.0

Runtime Versions: | AIR 1.0, Flash Player 9

Lets you construct a regular expression from two strings. One string defines the pattern of the regular expression, and the other defines the flags used in the regular expression.

Parameters

| `re:String` — The pattern of the regular expression (also known as the constructor string). This is the main part of the regular expression (the part that goes within the "/" characters). Notes:

- Do not include the starting and trailing "/" characters; use these only when defining a regular expression literal without using the constructor. For example, the following two regular expressions are equivalent:
  Copy

       var re1:RegExp = new RegExp("bob", "i");
              var re2:RegExp = /bob/i;

- In a regular expression that is defined with the `RegExp()` constructor method, to use a metasequence that begins with the backslash (\) character, such as `\d` (which matches any digit), type the backslash character twice. For example, the following two regular expressions are equivalent:
  Copy

       var re1:RegExp = new RegExp("\\d+", "");
              var re2:RegExp = /\d/;

  In the first expression, you must type the backlash character twice in this case, because the first parameter of the `RegExp()` constructor method is a string, and in a string literal you must type a backslash character twice to have it recognized as a single backslash character.

| `flags:String` — The modifiers of the regular expression. These can include the following:

- `g` — When using the `replace()` method of the String class, specify this modifier to replace all matches, rather than only the first one. This modifier corresponds to the `global` property of the RegExp instance.
- `i` — The regular expression is evaluated without case sensitivity. This modifier corresponds to the `ignoreCase` property of the RegExp instance.
- `s` — The dot (`.`) character matches new-line characters. Note This modifier corresponds to the `dotall` property of the RegExp instance.
- `m` — The caret (`^`) character and dollar sign (`$`) match before and after new-line characters. This modifier corresponds to the `multiline` property of the RegExp instance.
- `x` — White space characters in the `re` string are ignored, so that you can write more readable constructors. This modifier corresponds to the `extended` property of the RegExp instance.

All other characters in the `flags` string are ignored.

More examples

Regular expression syntax
Method Detail

### exec

()
method

`AS3 function exec(str:String):Object`

Language Version: | ActionScript 3.0

Runtime Versions: | AIR 1.0, Flash Player 9, Flash Lite 4

Performs a search for the regular expression on the given string `str`.

If the `g` (`global`) flag is not set for the regular expression, then the search starts at the beginning of the string (at index position 0); the search ignores the `lastIndex` property of the regular expression.

If the `g` (`global`) flag is set for the regular expression, then the search starts at the index position specified by the `lastIndex` property of the regular expression. If the search matches a substring, the `lastIndex` property changes to match the position of the end of the match.

Parameters

| `str:String` — The string to search.

Returns

| `Object` — If there is no match, `null`; otherwise, an object with the following properties:

- An array, in which element 0 contains the complete matching substring, and other elements of the array (1 through n) contain substrings that match parenthetical groups in the regular expression
- `index` — The character position of the matched substring within the string
- `input` — The string (`str`)

More examples

Methods for using regular expressions with strings

Related API Elements

String.match()
String.search()
Example ( How to use this example )
When the `g` (`global`) flag is not set in the regular expression, then you can use `exec()` to find the first match in the string:

             var myPattern:RegExp = /(\w*)sh(\w*)/ig;
             var str:String = "She sells seashells by the seashore";
             var result:Object = myPattern.exec(str);
             trace(result);

Copy

The `result` object is set to the following:

- `result[0]` is set to `"She"` (the complete match).
- `result[1]` is set to an empty string (the first matching parenthetical group).
- `result[2]` is set to `"e"` (the second matching parenthetical group).
- `result.index` is set to 0.
- `result.input` is set to the input string: `"She sells seashells by the seashore"`.

In the following example, the `g` (`global`) flag is set in the regular expression, so you can use `exec()` repeatedly to find multiple matches:

             var myPattern:RegExp = /(\w*)sh(\w*)/ig;
             var str:String = "She sells seashells by the seashore";
             var result:Object = myPattern.exec(str);

             while (result != null) {
                 trace ( result.index, "\t", result);
                 result = myPattern.exec(str);
             }

Copy

This code results in the following output:

                0      She,,e
                10     seashells,sea,ells
                27     seashore,sea,ore

### test

()
method

`AS3 function test(str:String):Boolean`

Language Version: | ActionScript 3.0

Runtime Versions: | AIR 1.0, Flash Player 9, Flash Lite 4

Tests for the match of the regular expression in the given string `str`.

If the `g` (`global`) flag is not set for the regular expression, then the search starts at the beginning of the string (at index position 0); the search ignores the `lastIndex` property of the regular expression.

If the `g` (`global`) flag is set for the regular expression, then the search starts at the index position specified by the `lastIndex` property of the regular expression. If the search matches a substring, the `lastIndex` property changes to match the position of the end of the match.

Parameters

| `str:String` — The string to test.

Returns

| `Boolean` — If there is a match, `true`; otherwise, `false`.

More examples

Methods for using regular expressions with strings
Example ( How to use this example )
The following example shows the use of the `test()` method on a regular expression in which the `g` (`global`) flag is set:
Copy

    var re1:RegExp = /\w/g;
    var str:String = "a b c";
    trace (re1.lastIndex); // 0
    trace (re1.test(str)); // true
    trace (re1.lastIndex); // 1
    trace (re1.test(str)); // true
    trace (re1.lastIndex); // 3
    trace (re1.test(str)); // true
    trace (re1.lastIndex); // 5
    trace (re1.test(str)); // false

Examples How to use this example
RegExpExample.as
The following example shows how you can use regular expressions to parse strings and return a new string or a Boolean value, based on the string passed in. The `informalizeGreeting()` method simply replaces the word `Hello` with `Hi`, regardless of case. It also strips out the surname in the name in the string (assuming that name matches the specified pattern). In the `validateEmail()` and `validatePhoneNumber()` methods, the string passed is checked to see if its pattern matches a valid email address or a specific phone number pattern, and the methods return Boolean values based on the results.
Copy

    package {
        import flash.display.Sprite;

        public class RegExpExample extends Sprite {
            public function RegExpExample() {
                var formalGreeting:String = "Hello, John Smith.";
                trace(informalizeGreeting(formalGreeting));    // Hi, John.

                var validEmail:String = "name@domain.com";
                trace(validateEmail(validEmail));        // true

                var invalidEmail:String = "foo";
                trace(validateEmail(invalidEmail));  // false

                var validPhoneNumber:String = "415-555-1212";
                trace(validatePhoneNumber(validPhoneNumber));    // true

                var invalidPhoneNumber:String = "312-867-530999";
                trace(validatePhoneNumber(invalidPhoneNumber));  // false
            }
            private function informalizeGreeting(str:String):String {
                var pattern:RegExp = new RegExp("hello, (\\w+) \\w+", "i");
                return str.replace(pattern, "Hi, $1");
            }
            private function validateEmail(str:String):Boolean {
                var pattern:RegExp = /(\w|[_.\-])+@((\w|-)+\.)+\w{2,4}+/;
                var result:Object = pattern.exec(str);
                if(result == null) {
                    return false;
                }
                return true;
            }
            private function validatePhoneNumber(str:String):Boolean {
                var pattern:RegExp = /^\d{3}-\d{3}-\d{4}$/;
                var result:Object = pattern.exec(str);
                if(result == null) {
                    return false;
                }
                return true;
            }
        }
    }

© 2015 Adobe Systems Incorporated. All rights reserved.
Mon Apr 10 2017, 12:28 PM -07:00