Regular expressions or rejects define a search pattern that could be used to search for things in a string.

Now this course focuses on using regular expressions in JavaScript.

However, almost everything you learn about regular expressions in this course can also apply.

If you're using regular expressions in another programming language, my name is Bo Kearns.

I will be teaching this course I'm with free Coke, camped out or GE.

In fact, this whole course is based on the free curriculum at Freak Oh camped out Warg.

It's not required to go through that curriculum to also do this course, but it could be helpful.

However, this course is designed to be stand alone.

But if you want to go through the curriculum on Freak, oh, camped out organs well, you can look in this picture where it has a row right to the regular expressions part of the curriculum, so you can see where that's at.

Well, let's get started.

Regular expressions are used in programming languages to match parts of strings.

You create patterns to help you do that matching So, for instance, if you have the sentence the dog chased the cat and you want to match the word the you can use This rejects here.

You can see that there's a slash in the word the in another slash You will also notice that quote marks are not required within the regular expression.

So JavaScript has multiple ways to use Reg X is one way is to test the rejects is to use the test method.

The test method takes the rejects, applies it to a string and then returns true or false, if the pattern matches something.

So in this example, we have the string Hello world.

We have this rejects and we have my rejects.

I'm gonna do dot test and then inside the parentheses I'm gonna put my string.

So we're going to see if my string contains this rejects, which is hello.

And then we'll put it into the result.

In this case, it will be true because hello world does contain the string.

Hello Here.

We want to match the word Waldo.

We have this sentence somewhere.

Waldo is hiding in this text.

So I'm gonna change this rejects instead of search.

It's going to be Waldo now.

One thing I wanna point out is that this is case sensitive.

So if I had a lower case W, then this would not match.

But since this starts with an uppercase W, I have to make the Rejects start with an uppercase w.

Also so there's a result the Waldo Reg IX dot test.

While Waldo is hiding, it's going to return.

True because it found Waldo in this sentence.

Rejects has an or operator, which is a single pipe character.

So in this example, let's say we want to try to match for multiple words instead of just a single word.

Let's say we want to match dog, cat, bird or fish.

So what I would do here is I'm going to change this.

I'll do dog and it'll put hype, which is just a straight line up and down.

And then I'll do cat I bird like fish.

So this is going to match any of these four words dog or cat war, bird or fish?

And since one of these words is in the sentence, this test is going to return true.

So far, all the reject says we looked at matched literal strings, so the case mattered.

If it was a capital letter that's completely different from a lower case letter.

You can match both cases using what is called a flag.

So there's the I flag that ignores case.

So let me show you how you would do that.

Let's say we have a free code camp and we'll see it's all lower case in here, but we want a match it no matter what the case.

So we want this to also match this where there's a Capital C and another capital C.

So just after the last slash, I'm just going to put an eye.

So this is the flag.

This means ignore case.

So now when it tests the string freak Oh, camp for the rejects, which is freak Ocampa, lower case, the result will be yes, because they will match.

So far, we have just checked if a pattern exists or not within a string.

But we can also extract the actual matches that we found with the match method.

So let's see how to extract the word coding from this string.

So we'll just change this to coating and then here will use the dot match Method match and then in the parentheses.

Will passion coding Reg X and then if we just run this, we'll see in the console coating because it's logging out.

The results, either result extracted.

This were coating out of the sentence and into the result variable, and it got logged.

So far, we've only extracted search patterns one time.

But it is also possible to search or extract a pattern more than once using the G flag.

Let me show you what I mean.

We have this test string up here.

Repeat, repeat, Repeat.

Now we're going to search for a repeat.

And the wait is now.

When it matches this, it's on Lee going to return the first Repeat just this one.

But if we add the G flag after the slash here, it's going to find every single occurrence of the word.

Repeat.

So it's going to return an array with three elements and each element is gonna be the word.

Repeat.

Let's see it again down here.

Where says twinkle, twinkle, little star.

I want to match the word twinkle so I'll type and twinkle right here and you'll see that the first week was capitalized.

The 2nd 1 is not so.

I'm gonna have to use a flag out to use the I flag, which makes it insensitive to case.

So it's case insensitive.

I'm also gonna add the G flag that's gonna match every single time Twinkle appears, so you can use to flags at once on the same rejects.

Now here, for the result is going to twinkle star dot match And then I'm going to pass in the star Reggie Dex.

Okay, now we'll log this and see what happens.

You can see twinkle, twinkle The first twinkle in the console is the Capital T and the second's a lower case because it matched the 1st 1 and the 2nd 1 and returned them both.

In Reg IX, a period is a wild card character.

It can stand for anything.

So let me show you an example.

We have these two strings up here, and the 1st 1 has the word hum.

The 2nd 1 has the word hug.

You'll notice that these two words start with the same two letters h u.

And then the third letter is different.

So look at this Rejects here h u period.

This will match any word that starts with the characters H.

U and then then has a final character, which could be any character.

So if we look down here, we are going to take the first string Al Hama song and match it to our rejects, its going to return home.

And then when we take our second string bear hug and match it to our rejects, its going to return hug.

So let's try that with another sentence.

We have the sentence here.

Let's have some fun with regular expressions, so I want to match the word fund.

But I also want this rejects to be able to match the word run son pond, non or bun, Basically any word that ends with you in and starts with another letter, so I'll change this rejects to dot u.

N.

So when we run our Reg X and search this sentence for something that ends with you in, it should find fun.

So let's load, then look in the console and it says, true, because it matched the word fund.

In that sentence, we talked about the wild card character, which matches basically anything, but you can also match from a pre defying group of characters.

If we look at this right here.

It we have the b and then we have these brackets and inside the brackets were saying that the second letter that's gonna match has to be one of these three letters.

So we know the first letters.

Let me be.

The last letter is gonna be G.

And the middle letter is gonna be a I or you.

So this would match bag big and bug.

So down here, what we want to do is change this.

So we match every single avowal in this quote sample here.

So what I'm gonna do is put open and close brackets and inside I'm gonna put the vowels a e i o u.

And then to make sure I match every single vowel and I am match uppercase or lower case fouls, I'm gonna use flags.

I'll use the I flag and the G flag.

Now, down here, I'm going to have to do quote, sample that match, and then I just pass in the valve rejects.

Here, I run this in the console.

You'll see all the vowels from that quote sample.

You can also match a range of letters.

So let me show you how to do that right here.

I'm gonna try to match every single letter.

So I'm going to put the open and close brackets.

And instead of typing a B C D e f g and rang every letter, I could just put a through Z.

So it's gonna match every letter between A and Z and then to make sure it matches every uppercase and lowercase letter.

I'll do I and then G to make sure it matches every letter in the whole string.

So now I could just do quote, sample maps and then I just pass in the alphabet, rejects here.

And if I run that we see in the consulate has every letter in that string, just like you can use the rejects to match a range of letters, you can also match a range of numbers.

So if I want a match range of numbers, it will be like this.

I'll have the brackets here, the opening closing brackets.

And this time I'm just gonna match the numbers two through six.

So just put to death six.

So that will match 23456 also in the same Reg X.

I can match a range of numbers and a range of letters.

So if I want to add some letters, I can put H through s.

So now we can see this is going to match a range of numbers two through six and also a range of letters h through s so I can do an eye to make it case insensitive and a G to match every occurrence in the whole string.

So I'm gonna put that into my results.

So I'll do quote, sample that match to match this Reg X.

And here it's going to confident log the results.

So it's what happens.

And we have every letter and number between those ranges.

We've talked about how to match for specific characters, But what if you want to create set of characters that you do not want to match these air called negated character sets and you can create them with the carrot character?

So let me show you how to do that.

This we want to make a MME rejects that will match everything except all numbers and all vowels.

So we're going to put a opening close bracket, and I'm gonna put a carrot character that's right underneath a six on a keyboard and open zero through nine.

So we are not going to match all digits zero through nine and we're not going to match a e i o u.

And then I will put my flags here I d So this will match everything except zero through nine and a e i o u.

So to finish this up, I'm going to put quote sample dot match seminal pests in the rejects here and now I'll just run this and you can see we've returned everything except the vows and the numbers.

It includes the spaces and periods and punctuation also.

Sometimes you want a match if a character occurs one or more times.

If you want to do that, you can use the plus character.

So let me show you how to do that.

In this case, we're going to try to match in the word Mississippi whenever an S occurs one or more times.

So I'm just gonna put s plus and I'm gonna put a G to match it every time it occurs.

And if I run this, you'll see we have matched the first SS and then the second s s.

If they're just happened to be another s.

And here we would then match three times and you can see the third time only matches the single s because there's only one s in a row.

There is an option to match characters that occur zero or more times.

That's with this star character here.

So this rejects means match, Aggie and then matching 00 or more times.

So with this word goal, it's going to return g o.

And then every Oh, after it.

And then here, gut feeling There's a G with no goes after it, incidents matching zero or more times.

It's going to match that and just return G.

Now this one has No, it hasn't owes what doesn't have a G.

So it's gonna return.

No, it's not gonna match at all.

So down here we're going to do some coding and match a zero or one time.

So I'm going to change the change word here, and we always want to get the capital a and then for the lower case A.

We're going to do it a ass trick so it can match this whole thing of A's here.

So if I just do a council that log here and the result.

It should match all of the AIDS.

It worked.

I am going to talk to you about greedy and lazy matches.

A greedy match finds the longest possible part of the string that fits the Reg X pattern and returns it as a match.

A lazy match finds the smallest possible part of the string and returns that Reg Ex patterns default to greedy.

Let me show you what I mean.

Let's look at the string here Titanic, and we'll look at this rejects to find something in the string Titanic.

First we're looking for the letter T.

And then this part means after the letter T, we went zero or more of any letter.

So are this Means any letter A through Z, the Astra car star means zero arm or occurrences of this a through Z.