In today's video, I'm gonna be talking about regular expressions and I'm gonna be going in depth, covering everything you need to know about regular expressions.

This includes the simple stuff such as matters, digits, selectors and so on, all the way up to more advanced features such as captured groups.

Negative.

Look ahead positive.

Look ahead and so on.

So let's get started now.

Welcome back to Webb.

Have simplified my name's Kyle and my job is to simplify the web for you so you can start building your dream project sooner.

So that sounds interesting.

Make sure you subscribe to the channel for more videos just like this one.

And now to get started, I'm gonna website here, which really helps with regular expressions.

I'm gonna link it down in the description below so you could go to the same blood site.

But it's really useful because it highlights inside of the texture, searching for what your regular expression actually masses and give you details on every single thing that the regular expression is doing.

It's great for practicing and testing out regular expressions, so I highly recommend you go down to the link in the description and follow along on this site and now to get started.

I first want to explain what regular expressions are.

And essentially a regular expression is a way to search through a string of text.

So we have this text in here and at the top.

We have a regular expression, and with that regular expression allows us to do is it allows us to search through that text in order to do things such as validation or get certain pieces of the text we can do advanced find in replace.

There's a ton of things that you could do with regular expression.

But in general, all that regular expression is doing is it allows you to search their text in a really advanced way and even group those different searches together so you could do powerful things such as finding your place with it.

So to get started, I kind of want to break down the format of a regular expression.

As you can see up here, we have our regular expression, and in the middle here we have our text were searching and regular expression is almost always gonna start with this opening slash share this forward slash, and it's going to end with a Ford Slash as well.

A lot of programming languages.

When you define regular expressions instead of defining them in sort of stream quotations, you find them inside of these Ford slashes.

So everything between the Ford slashes is going to be your regular expression, then also something that's a part of a regular expression is the part after the forward slash here at the end these air, the different flags.

And as you can see, we can access these flags up here, and the main ones that you need to know about is global.

This allows you to match anywhere in the string.

For example, if we did at here, you can see that it matched all three of the different hats.

That's because we have global.

It allows it to do multiple matches, but if we take global off, it's only going to match.

The first result that we find so essentially global is like match all while without global is like match one.

Next, we have case insensitive.

So, for example, if I put the with a capital T h here and then if I make this global, you can see it's matching both of these those And that's because I have case in sensitive turned on.

If I turn that off, it's on Lee gonna match the that is capitalized.

And if we changes to a lower case, it's only going to match the lower case one.

For the purposes of this tutorial.

I'm just going to leave us on the global flag with case sensitivity is that way.

Capitals actually make a difference.

And that's just because this is the most general configuration that you're going to use, one messing with regular expressions and to get started.

As you can see, this works very much like a normal find.

If I type information into here, whatever type is going to be searched for in the string down here, for example, at I can search for Fat and I'm just going to get the word fat do ran and so on, and it works just like normal finding a place which is not really that powerful.

But where does become powerful is when you can actually start adding in the regular expression things, and the very 1st 1 that I want to talk about is the idea of these different special characters that allow you to do certain things.

So, for example, we can search for the character E.

And you can see we get every single e inside of our search.

But what if we wanted to search for a string of these so multiple ease in a row?

We could put E and then we could put a plus.

And what this is saying, Is it saying match E?

But we want a match.

At least one.

This is one or more of the proceeding token, so we're saying Match E or more than one e.

So you can see we have this baby and match this e.

But this is actually matching both of Artie's because there's two e's in a row and the pluses just saying match as many in a row as you can but match at least one and then another character that we can do.

For example, we can put in a in here and we can put a question mark, and that's saying that this is optional so optionally I want to get this a character.

So here we have e A.

So it's going to get the character E as you can see in all of these, and then if there's an A, it's also going to bash it.

So this question mark says zero or one.

I like to think of it as whatever is before.

It is optional.

Sonar case are a is optional, and wherever there's an A after an E, it's matching it.

But in the case where there's no way after the it's just completely ignoring it, the next one I want to talk about is going to be here.

The star indicator and the star indicator essentially says Match zero or more.

So it's kind of like a combination of the question mark and the plus.

It's saying that it's optional, but you could match as many as possible in a row.

So when we can see this is if we do our e and then Starr, you can see it's matching anything in here that is an R, and then it matches all of the ease that follow it.

If there are any, and if not, it just matches the art itself.

Another special character that's really important is the period character, and the idea of the period character is that matches literally anything at all.

So as you can see here, we put the period and it's matching the F, the sea and the it doesn't matter.

It'll match anything except for a new line.

It won't match a new line.

So we have a new land right here.

And if, for example, we wanted to search for tea and then we want to search for a period and we want to search for another period, you can see that it's not actually wrapping the new line because period can't match a new line.

Also, you may notice that we want to search for a period.

For example, how do we find all of the periods we can use here?

The backslash and in the period and with the backslash allows us to do is just cancel out anything that comes after it had essentially escapes it.

So since we have this special character period after it, it's saying, treat this as a normal period and not as the special wild card period that matches everything.

And as you can see, we're able to match any of our periods.

And if we wanted to say what's match?

Any character that comes before we could just put it, period.

And now we're matching any character that comes before period as well as the period.

Another really important special character that we can actually use here is going to be the slash w.

And this is saying match any word character.

So this is going to be things like letters.

As you can see here, it's matching every single letter in our list.

Also, there's the's slash s this is going to match any form of white space that there is.

And the nice thing is, these have negative versions.

So Capital s is going to match anything that's not a white space capital.

W matches anything that's not a character such as these letters here.

And what say we wanted to capture all of the words better longer than four characters long?

Well, we can't use the plus.

We can't use the star.

These don't actually work, but we can do is inside of curly braces.

We can put a minimum and a maximum number for how large we want something.

So, for example, let's say we wanted to get all the words that are over four characters.

We could say four and this is going to get us any four digits in a row, and if we put a comma, it's going to say, Get any four digits or more.

If you wanted to get 4 to 5 characters, we would say 4 to 5 and is going to match any set of characters that are between four and five long and that right there is pretty much the majority of all of your counting selectors as well as your special character selectors that you have to worry about.

But another thing that you can do is actually do character groupings so we can get all of the characters inside of a group.

So, for example, let's say that we wanted to get any single word that ends in a tea, and we wanted to get a three letter word that ends in a tea, and we wanted to get only the words that start with either F or see what we could do here as inside of square brackets.

We put any characters that we want a match, and it's saying, match any of the characters inside of here, for example, it's going to match anything that starts with F or a C and ends with an A T.

But the really useful thing about these character sets, but you can actually do ranges.

So we could, for example, a dizzy and this is going to be all of the characters between A and C.

We could also do between Capital A and Capital Z, and now we have all of the characters between A and Z that are lower case and all the characters between A and Z Better upper case.

But I'm going to be checked inside.

This regular expression could do the same thing, for example, with 0 to 9 if we wanted to.

It's really useful because we can do these large ranges which allow us to do these really specific checks.

For example, we could do like a deaf, and it's going to get anything between A and F We could do a to C, and we're just gonna get cat now.

In that case, something else that's really useful is the ability to put things inside of a group, and that's what we use Parentheses for anything inside of the parentheses are going to be their own group, and they only act upon themselves so For example, we could search for tea or upper case T lips, upper case T.

And with visit Does this little pipe character here?

Is it Saint match Any of these?

So it's like a or result is saying either lower case T or upper case T.

And then we want to match H E afterwards.

So this allows us to match uppercase tea or lower case T.

And it's going to allow us to match it for the word, uh, and the reason we need parentheses.

This because if we remove these parentheses, this character here is going to check for either lower case T or the entire word, the because it's going upon the thing on the left and the thing on the right.

But with the parentheses, we can actually break this up into its own group.

So now it's on Lee acting upon the tea and the uppercase tea instead of the full word.

The also something that's really useful with these groups is we can actually do something things such as our matters where we could say we want a match, for example, 2 to 3, and it's going to say we want a match 2 to 3 of this character group in here.

So you're over Case T or upper Case T.

And so we can actually see this in effect by doing If we want t e and R, you can see it's going to match between two and three of these.

Let's just say we want to match between two and three of those and you can see it's matching over here tr ee because it's in this group.

There's at least three of these and then e t because there's two of them.

And then, for example, we could even put things after this.

For example, you want to match the period key and you can see is giving us the E.

T period at the end because it's checking between two and three of these characters up here in the beginning.

And then it's saying the actual period keys coming after.

So what?

The's capture groupings.

What we can do is we can actually specifically say we want to do special things only to those groupings, so anything that we put after these groupings are going to affect the entire grouping and not just a single character inside of that grouping as we were doing before, because, for example, we remove all this.

We just changed us to, for example, e of 2 to 3.

What this is doing is only acting upon this e.

And if we put for example and are in here, it's not acting upon this art.

All this are is completely separate from the But if we were to put it inside of a group like this.

Now what this is saying is any set of R E that is seen in a row 2 to 3 times.

So, for example, if we put our tr ee, you can say that's going to match it.

We put another one to match it.

But of course the 4th 1 will not now.

Another special character, which is really important to get used to, is the carrot symbol, which essentially says match the beginning off the line.

So, for example, we put the tea here.

It's going to match the beginning of our statement.

But if we put a capital I and the carrots symbol, you can see that it's not working, and that's because we're doing this as one whole chunk of text.

So this carrot is the very beginning of our entire chunk.

If we wanted to do it per each individual line, we would need to set the multi line flag.

And now that's saying that this carrot symbol is the beginning of each and every line that we have.

Instead of just the beginning of the actual statement as a whole.

I'm gonna turn that back off just so that we know that this is going to be the very beginning of our entire statement.

So, for example, our tea is going to match this tea here.

And we could put you know, for example, that and it's gonna match that a whole word, the but only going to match the the very beginning even if we made it so that it could be a lower case t by doing this so it could be either uppercase tea or lower case T.

You can see it's still not matching.

But if we remove this, you can see now it matches both of those.

Another thing that you can do is the dollar signs symbol on with this is saint is matched the end of our statement.