RegExp Character Sets

How can you select all the words within a string that follow the pattern 'b', then a vowel and finally the alphabet 't'. In other words how can you match all the words 'bat', 'bet', 'bit', 'bot', and 'but'.

Luckily you might be able to see a pattern in this case - the characters between the 'b' and 't' are changing while they both remain the same. What we need is a character set.

So far we've explored a handful of concepts including flags and quantifiers in our regular expressions journey. Fortunately this exploration is not over as of yet!

In this chapter we shall take a look at another powerful concept in regexp known as character sets that can give a range of characters to match a character with. Let's enroll!

In simple terms:

A character set essentially provides a bunch of characters to match against a single character in a given test string.

For example, if you want to match the characters 'a' or 'b' you can simply write /[ab]/. The set will match either an 'a' or a 'b' in a given test string.

The order of characters here doesn't matter - we could've also used the set [ba]. The reason is because, internally the regexp engine matches a character in the string against each character in a set until a match if found.

Similarly to match the characters 'a', 'b', 'c' or 'd', you can construct the character set [abcd]. Once again remember that this set will resolve down to a single character - in this case either an 'a', 'b', 'c' or a 'd'.

Often developers make the mistake of thinking that a character set denotes a word, but this is not the case. In itself, a character set is meant to denote only a single character.

What this simply means is the fact that [How] won't match the word 'How', but instead the characters 'H', 'o' and 'w'.

Speciality changes inside a set!

One thing worth mentioning over here is that not all characters, considered special inside a regular expression, are also considered special inside a character set.

For example, ? + * : | . all are considered special inside a regular expression, but are NOT special inside a set. This means that they can be given without a backslash.

Likewise, the set [.] isn't equivalent to the wildcard . character. The pattern /./ will match any single character, however the set [.] will match only the period symbol '.', literally.

Listing all non-special characters inside a set will otherwise be quite tedious so we'll approach it the other way - listing all special characters.

What is considered special inside a set includes:

1. The caret ^ only if it appears at the start of the set. This is the negation character and likewise denotes a negation set as we shall discover below.
2. The hyphen - if it appears between two characters. It denotes a range inside a set as we shall see below.
3. The backslash \ which can be used to include character classes inside a set. We'll see what are character classes in the next chapter.

To include any of these special charcters in the given locations, like a hyphen between two characters, we ought to use the backslash \ to escape them.

A character set on its own will always resolve down to a single character. A quantifier, however, can quantify it to match any of the specified characters a given number of times.

For instance /[ae]+/ will match 'a', 'e', 'ae', 'ea', 'ee', 'aa', 'aea' and so on. The regexp engine will match each character in the test string with the characters in the set and as soon as a match is found, will proceed to match against the next character, depending on the quantifier used.

The expression /[ae]+/ will thus match the first sequence of the characters a and e (in any order) of length 1 or greater.

There are many instances when we want to include a range of characters inside a character set.

For example in the occasion of matching one of the characters 'a', 'b', 'c' or 'd' we can either use the set [abcd] (as we saw above); or noticing the fact that this is a range of characters i.e a to d, we can reduce it down to [a-d].

Going with the same example above, we can use the set [a-d], instead of [abcd] to match either a, b, c or d.

In the same way the set [a-z] will match any character between a and z; [A-Z] will match any character between A and Z. Digits can also be given as in the set [0-9], which will match any digit between 0 and 9.

The idea of a range in a set is quite powerful and efficient. Instead of writing sets like [abcdefghijklmnop] we can simply define these in terms of ranges i.e [a-p] and get our job done in the span of seconds.

What's even more interesting is that we can define multiple ranges in one set.

For example the set [a-z0-9] matches any digit or lowercase alphabetic character. As you can see here, we've used two hyphens with characters on each of their sides to denote two ranges. Amazing isn't it?

Thing to note!

One thing to note when working with ranges is that they must have comparable characters as their starting and ending values.

What this means is that a range like [a-Z] won't be understood by the regexp engine; the starting value is lowercase whereas the ending value is uppercase and hence are NOT comparable to each other.

In contrast, [a-z] and [A-Z] both contain comparable characters denoting the ranges - lower a to lower z, and upper A to upper Z respectively.

Say you want to write an expression to match all sequences of characters in a string that don't include 'a' in them. If you have begun to construct the expression by writing all possible characters on your keyboard, then you've already taken the wrong way!

What we need is a negated set...

Where a normal character set matches the characters listed within it,

Whatever is inside a complemented set, that is excluded from the match and everything else is considered instead.

For example, [^a] denotes a negated set that matches all characters that are NOT 'a'.

Although this is just a fairly simple example, the ways in which you can construct a normal set also apply to negated sets i.e negated sets can also have ranges.