RegExp (ActionScript 3.0)

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
		prototype : Object [static] A reference to the prototype object of a class or function object.	Object
		source : String [read-only] Specifies the pattern portion of the regular expression.	RegExp

Public Methods

Hide Inherited Public Methods

Show Inherited Public Methods

	Function		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
		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]

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

Example
The following example shows the effect of the s (dotall) flag on a regular expression:

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]

Specifies whether to use extended mode for the regular expression. When a RegExp object is in extended mode, whitespace 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

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 whitespaces in the string to be ignored.

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]

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

Example
The following example shows the effect setting the g (global) flag on the exec() method:

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]

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

Example
The following example shows the effect of setting the i (ignoreCase) flag:

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 [read-write]

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 lastIndexproperty.

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

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:

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]

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

Example
The following example shows the effect setting the m (multiline) flag:

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]

Specifies the pattern portion of the regular expression.

Implementation
public function get source():String

Example
The following code outputs the source parameter for two regular expressions:

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)

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).

Note: Do not include the starting and trailing "/" characters; use these only when defining a regular expression literal without using the contructor function.

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 — Whitespace 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.

Method detail

exec method

public function exec(str:String):Object

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)

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);

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);
  }

This code results in the following output:


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

See also

String.match(), String.search()

test method

public function test(str:String):Boolean

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

Parameters

str:String — The string to test.

Returns

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

Example
The following example shows the use of the test() method on a regular expression in which the g (global) flag is set:

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

Class examples

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 formalizeGreeting() method simply replaces the word Hello with Hi if it is found in the string passed to it, regardless of case. In the email() and ssn() methods, the string passed is checked to see if its pattern matches a valid email address and Social Security number and the method returns a Boolean value based on the result.

package {
    import flash.display.Sprite;

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

            var validEmail:String = "name@domain.com";
            trace(Validate.email(validEmail));            // true
            
            var invalidEmail:String = "foo";
            trace(Validate.email(invalidEmail));        // false
            
            var validSSN:String = "123-45-6789";
            trace(Validate.ssn(validSSN));                // true
            
            var invalidSSN:String = "123";
            trace(Validate.ssn(invalidSSN));            // false
        }
        
        private function formalizeGreeting(str:String):String {
            var pattern:RegExp = new RegExp("hi, (\w+)", "i");
            return str.replace(pattern, "Hello, $1.");
        }
    }
}

class Validate {    
    public static function email(str:String):Boolean {
        var pattern:RegExp = /(\w|[_.\-])+@((\w|-)+\.)+\w{2,4}+/;
        var result:Object = pattern.exec(str);
        if(result == null) {
            return false;
        }
        return true;
    }
    
    public static function ssn(str:String):Boolean {
        var pattern:RegExp = /\d{3}-\d{2}-\d{4}/;
        var result:Object = pattern.exec(str);
        if(result == null) {
            return false;
        }
        return true;
    }
}

ActionScript 3.0 Language Reference	All Packages \| All Classes \| Language Elements \| Index \| Appendixes \| Conventions \| Frames No Frames
Class RegExp	Constants \| Constants \| Properties \| Properties \| Styles \| Effects \| Events \| Constructor \| Methods \| Functions \| Interfaces \| Classes \| Use \| Examples

Package	Top Level
Class	public dynamic class RegExp
Inheritance	RegExp Object