Saturday, March 12, 2011

regular expression in javascript



A regular expression object is an instance of the RegExp object. Each regular expression object consists of a
pattern that is used to locate matches within a string. Patterns for a regular expression can be simple strings or
significantly more powerful expressions that use a notation that is essentially a language unto itself. The
implementation of regular expressions in JavaScript 1.2 is very similar to the way they are implemented in Perl.
You can read more about these concepts in books covering JavaScript 1.2 or later.


To create a regular expression object, surround the pattern with forward slashes, and assign the whole
expression to a variable. For example, the following statement creates a regular expression with a pattern that
is a simple word:

var re = /greet/;

The re variable can then be used as a parameter in a variety of methods that search for the pattern within some
string (you may also use an expression directly as a method parameter, rather than assigning it to a variable).


Regular expression notation also consists of a number of metacharacters that stand in for sometimes complex
ideas, such as the boundary on either side of a word, any numeral, or one or more characters. For example,
to search for the pattern of characters shown above but only when the pattern is a word (and not part of a
word such as greetings), the regular expression notation uses the metacharacters to indicate that the pattern
includes word boundaries on both sides of the pattern:

var re = /\bgreet\b/;

The following table shows a summary of the regular expression notation used in JavaScript 1.2.


When you create a regular expression, you may optionally wire the expression to work globally (as you
probably do if the regular expression is doing a search-and-replace operation with a method, and your goal
is a "replace all" result) and to ignore case in its matches. The modifiers that turn on these switches are the
letters g and i. They may be used by themselves or together as gi.


Once you have established a pattern with the regular expression notation, all the action takes place in the
regular expression object methods and the String object methods that accept regular expression parameters.

Character Matches Example
\b Word boundary /\bto/ matches "tomorrow"/to\b/ matches "Soweto"
\B Word nonboundary /\Bto/ matches "stool" and "Soweto"/to\B/ matches "stool" and "tomorrow"
\d Numeral 0 through 9 /\d\d/ matches "42"
\D Nonnumeral /\D\D/ matches "to"
\s Single whitespace /under\sdog/ matches "under dog"
\S Single nonwhitespace /under\Sdog/ matches "under-dog"
\w Letter, numeral, or underscore /1\w/ matches "1A"
\W Not a letter, numeral, or underscore /1\W/ matches "1%"
. Any character except a newline /../ matches "Z3"
[...] Any one of the character set in brackets /J[aeiou]y/ matches "Joy"
[^...] Negated character set /J[^eiou]y/ matches "Jay"
* Zero or more times /\d*/ matches "", "5", or "444"
? Zero or one time /\d?/ matches "" or "5"
+ One or more times /\d+/ matches "5" or "444"
{n} Exactly n times /\d{2}/ matches "55"
{n,} n or more times /\d{2,}/ matches "555"
{n,m} At least n, at most m times /\d{2,4}/ matches "5555"
^ At beginning of a string or line /^Sally/ matches "Sally says..."
$ At end of a string or line /Sally.$/ matches "Hi, Sally."
constructor global ignoreCase lastIndex source
compile( ) exec( ) test( )
Creating a regular expression Object
var regExpressionObj = /pattern/ [g | i | gi]; var regExpressionObj = new RegExp(["pattern", ["g" | "i" | "gi"]]);
constructor NN 4 IE 4 ECMA 3 


See this property for the Array object.

global, ignoreCase



Returns Boolean true if the regular expression object instance had the g or i modifiers (respectively) set when
it was created. If a regular expression object has both modifiers set (gi), you must still test for each property

if ( && myRE.ignoreCase) {     ... }

Boolean value: true | false.



This is the zero-based index value of the character within the string where the next search for the pattern begins.
In a new search, the value is zero. You can also set the value manually if you wish to start at a different location
or skip some characters.

myRE.lastIndex = 30;




Returns a string version of the characters used to create the regular expression. The value does not include the
forward slash delimiters that surround the expression.

var myREasString = myRE.source;


compile( )

compile("pattern"[, "g" | "i" | "gi"])


Compiles a regular expression pattern into a genuine regular expression object. This method is used primarily
to recompile a regular expression with a pattern that may change during the execution of a script.

  • Any regular expression pattern as a quoted string. Modifiers for global, ignore case, or both must be
    supplied as a separate quoted parameter.
Returned Value

Reference to a regular expression instance.

exec( )



Performs a search through the string passed as a parameter for the current regular expression pattern. A typical
sequence follows the format:

var myRE = /somePattern/; var resultArray = myRE.exec("someString");

Properties of both the static RegExp and regular expression instance (myRE in the example) objects are updated
with information about the results of the search. In addition, the exec( ) method returns an array of data, much
of it similar to RegExp object properties. The returned array includes the following properties:


Zero-based index of starting character in the string that matches the pattern


The original string being searched


String of the characters matching the pattern


Strings of the results of the parenthesized component matches


You can stow away the results of the exec( ) method in a variable, whereas the RegExp property values change
with the next regular expression operation. If the regular expression is set for global searching, a subsequent call
to myRE.exec("someString") continues the search from the position of the previous match.


If no match is found for a given call to exec( ), it returns null.

  • The string to be searched.
Returned Value

An array of match information if successful; null if there is no match.

test( )



Returns Boolean true if there is a match of the regular expression anywhere in the string passed as a parameter,
false if not. No additional information is available about the results of the search. This is the fastest way to find out
if a string contains a match for a pattern.

  • The string to be searched.
Returned Value

Boolean value: true | false.

No comments :

Post a Comment