If I ask you whether these two words match,

you'd most likely glance at them both and say, hm, yes.

However, a regular expression doesn't work that way.

Instead, it uses a parser which compares each character in a regular

expression with a character in the string in the same position.

In other words, the regex parser requires two things.

An expression, also called a pattern, and a string to match.

The parser takes that pattern and walks through the string,

character by character.

First, it checks if there is a t.

Then if the t is followed by an o.

Which is followed by a y, then a b, o,

a, all the way to the t at the end.

At that point, the parser knows the string is a match.

I'm going to type toyboat into regexpal, in the regex pane, in the testing pane.

You can see there is a match selected here.

This is the basic matching we saw earlier.

Let's say we want to match the singular or the plural.

If I add an s to the regex, we lose our first match.

However, we can make this final s optional.

Match it if it exists but don't require it.

We can do that with another special regex character, the question mark.

The question mark matches the character that appears directly before it

zero times or one time.

In this case, the lower case s is before the question mark, so s is optional.

But if it does appear, it can only appear once.

So this regex will match toyboat or toyboats but not toyboatss with two S's.

Let's use the question mark in the middle of the string.

Let's match toybots, too.

We can put a question mark after the a to make it optional also.

It works.

I'll replace toybots with toyboats again, but this time with a space.

Just like before,

we can handle this with a question mark, making the space optional.

Now let's say that we want to match toy, even if it's capitalized.

Regular expressions are case sensitive by default, so

we'll need to specify that the T can be upper or lower case.

We can tell the interpreter to accept a capital or

lower case t by wrapping both characters in square brackets.

Let me show you what I mean.

I'll put a capital T next to the lowercase t, and surround both with square brackets.

I just added what is called a character set to the regex.

When the interpreter sees it,

exactly one of the characters in the set will match one position in the string.

We can specify as many characters as we want between these brackets.

Let's say we also want to match joy boats with a lowercase j, for example.

We can just put a j inside the square brackets.

There's two things to note.

No matter how many characters we put in the set,

the set will always match only one position of the string.

In this case, it's the first position.

It also makes no difference how you order the character set.

Now I wanted to give you a challenge.

I'll type out two more test cases for you.

See if you can modify the regex to match those

along with the strings it already matches.

I'll add a hyphenated version.

And another version with the B capitalized.

Go ahead and pause the video and see if you can do it.

For the hyphenated string, I replaced the space and

the regex with a character set containing a space and a hyphen.

Note that the question mark now indicates that the character set is optional.

In other words, the character between the y and the b can either be a space,

a hyphen, or nothing at all.

For the second string,

I used a character set to match either a lower or upper case B.

I've added some additional strings for

you to practice on in the teachers notes below.

Take some time to try then now if you'd like.

In the next video, I'll show you how to add a little more power to character sets.