RegExp Backreferencing

In the previous RegExp Grouping chapter, we saw how to group up individual regex tokens into a single unit and then use this unit in the matching process just like a single token.

Particularly, two types of groups were explored: capturing groups which save their matches and non-capturing groups which don't save their matches.

In this chapter we shall specifically dig deeper into the former type, i.e capturing groups, and in the way understand the concept of backreferencing.

When a capturing group is used in a regular expression, whatever is matched by the group, that stuff is saved in memory for later use. This is where capturing groups get their name from - they literally capture their matches.

Now storing matches in memory would obviously be useless if we couldn't use them later on. Backreferencing is the name given to the action of using these matches.

In simple words, when we use up the captures made by capturing groups, we are backreferencing these captures.

We construct a capturing group, it matches something, saves it in memory and then we use this saved value in some other place. This is backreferencing!

Let's further clarify this with the aid of an example.

Say you want to replace all vowels in a string with a parenthesis followed by the vowel followed by another parenthesis. For example, the string "Abed" shall become "(A)b(e)d".

To accomplish this task we will definitely need the replace() method, since we need to perform replacements. Furthermore, we'll also need to save each matched vowel in memory so that while replacing it we could refer back to it and include it in the replacement string.

In contrary to this, if we only had to replace each e (not E) with an '(e)' from a given string, we could've simply used the following code:

var str = "Twenty three";
var patt = /e/g;

var replacedStr = str.replace(patt, "(e)");

Here there's no need to use a capturing group and then backreference the match, because we know exactly what will be matched - an e.

In cases where we don't know what will be matched, such as in replacing all vowels, we ought to use backreferencing to call on whatever was matched.

Don't worry if you haven't understood backreferencing till yet. The next section with all its examples will be more than sufficient to explain the concept in precise detail.

Now that we know what is backreferencing, it's time to see how to do it.

We can backreference a captured match in essentially two places:

1. A replacement string, i.e the second argument of the replace() method
2. The actual pattern

Inside a replacement string, a backreference is denoted by $n while in the pattern, it's denoted by \n where n is the number of the group.

Group numbers start at 1. The first group has the number 1, the second has the number 2 and so on. This means that to backreference the match of the first group we would use $1 in the replacement string and \1 in the pattern.

Let's solve the vowel problem we saw above using backreferencing.

var str = "Eighty one";
var patt = /* pattern goes here */;
var replacedStr = /* replaced string goes here */;

var str = "Eighty one";
var patt = /([aeiou])/ig;
var replacedStr = str.replace(patt, "($1)"); // "(E)(i)ghty (o)n(e)"

Let's now see how to backreference within a pattern.

In this way, backreferencing enables one to construct complex expressions that can match anything and then even use that anything for further refinement.

You would surely agree that backreferencing ain't that difficult.

You just have to be sure what you need to reference; do you even need a reference and a capturing group to solve the problem; and that which capturing group you are willing to refer to in an expression.

It's now your time to tackle backreferencing!

var str = "136593";
var patt = /(\d\d)/g;
var replacedStr = str.replace(patt, "-$1- "); // "-13- -65- -93- "

 //  example with string "465-768-9076"
var str = "465-768-9076";
var patt = /(\d+)-(\d+)-(\d+)/;
str = str.replace(patt, "($1) ($2) ($3)"); // "(465) (786) (9076)"

Now let's consider a handful of examples demonstrating groups within groups.

Now it's your turn to think through the expression and see what captures what.

And this finally completes the whole concept of grouping now that we've scrutinized backreferencing in great detail. Monotonously our regexp journey hasn't ended even as of yet, there are still quite many avenues to discover so don't just stop here - keep riding!