RegExp Methods

In the previous chapter we discovered the three string methods search(), match() and replace() and how they served different purposes of pattern matching.

In this chapter we shall explore the other basket of options i.e RegExp() methods to test for patterns within strings and extract substrings out of strings based on them.

Before starting on with anything, recall that we have seen a constructor way to create regular expressions back in the RegExp Basics chapter. We also know that a constructor throws out an object, which can then have properties and methods on it.

This means that all regular expressions, created literally or from the constructor are in effect instances of the RegExp() function and hence inherit methods from the prototype RegExp.prototype.

For a regular expression, there are two methods available (on the prototype object RegExp.prototype) namely test() and exec(). Both these methods are regexp methods and likewise operate slightly differently than the string methods we saw previously.

The first method which we will be looking over is the method test(). It takes as an argument the string to test the pattern on and returns true or false based on whether it contains the pattern anymore or not.

Let's consider a simple example illustrating the idea.

var str = "Hello World!";
var patt = /hello/;
console.log(patt.test(str)); // false

Since here the string doesn't contain the pattern /hello/, the method returns false.

Similarly we can take a look at another instance where the pattern is actually seen in the string.

var str = "Hello World!";
var patt = /hello/i;
console.log(patt.test(str)); // true

The output of test() here shouldn't at all be any surprising - str does contain the pattern patt and hence we get true returned.

So hopefully both these examples were fairly easy to understand. However what might not be easy and intuitive to understand at first glance is the behavior of this method when the global flag is set on the regular expression.

Consider the code below. The expression has the global g flag set and as we can see the string contains only one match for the pattern.

var str = "Hello World!";
var patt = /hello/ig;
console.log(patt.test(str)); // true

Just as before, we get true returned since the string does contain an occurence of the pattern. However if we recall this method in the next line, surprisingly, we get false returned. Did something chang; did something go wrong? Well nothing as such happened!

var str = "Hello World!";
var patt = /hello/ig;
console.log(patt.test(str)); // true
console.log(patt.test(str)); // false

What happens here is due to the presence of the global flag. It makes the method keep on its searching until the end of the string is reached. As soon as a match is found true is returned and the index after the match is saved for the next searching round. Once the end of the string is reached false is returned.

Let's apply this to our example above and try to make it easier to comprehend.

Once the whole string is analysed by the regexp method, the index resets all the way back to 0 and searching will restart in subsequent calls of the method.

This would mean that if you call test() the third time, it will return true. Fourth time again false; then true, then false and so on.

var str = "Hello World!";
var patt = /hello/ig;
console.log(patt.test(str)); // true
console.log(patt.test(str)); // false
console.log(patt.test(str)); // true

var str = "Hello World! Hello once again!";
var patt = /hello/ig;

console.log(patt.test(str));
console.log(patt.test(str));
console.log(patt.test(str));

// suppose str is the test string
// suppose patt is the test pattern
var success = patt.test(str) && patt.test(str)