[MUSIC]

Hello, I'm Craig and I'm a developer.

Regular expressions are an extremely handy tool to have at your disposal.

They're also incredibly intimidating looking if you don't know how or

why someone is using them.

Regular expressions are common in just about every programming language.

And developers have leaned on their power for many solutions.

We use them for searching, replacing, and

validating that text meets certain formats.

Java has several methods that you will encounter that expect a regular

expression as a parameter,

as well as a few very common patterns that you will more than likely encounter.

We've used them in a couple of our projects, and

I figured it was about time we did a little deeper exploration of their use,

and add them to your bag of tricks.

Are you ready?

Let's get started.

Regular expressions, or regexes, as they are often referred, are one of those

concepts that are hard to understand until you actually need to use them.

So I was thinking we'd run through some hands on examples so

you can get a vibe of how they might be used.

Now, when I'm writing a regular expression, I like to try and

find a visual editor for my specific language.

And there's tons of these online.

So let's do a quick search for one in Java.

So, let's say, Java.

Regular expression.

And we'll say, visual.

Let's just see what happens with that.

Okay, great, this first one here, Java Visual Regular Expression Tester.

Perfect.

Okay, so the way the tool works is this.

You put a string in there where it says Target text, and

then you write your regular expression or the pattern that you're looking for.

So regex is all about pattern matching.

So let's assume that I was writing some software that was gonna parse a cover

letter of a job applicant.

So let's say that it looked something like this.

Let's say that it said I am a full-stack developer.

I am fluent in JavaScript,

HTML, CSS and

PostgreSQL.

So let's say that we are wanting to find people who are confident in their skills.

And so we could type the literal word fluent.

And this is a regex.

And what's gonna happen is it's gonna match.

And so if you see down here on the bottom, it shows where we matched.

Okay, so see it's highlighted.

Fluent is highlighted there.

Now, that's probably not blowing you away.

The real power comes in when we expand our pattern.

So, everybody knows that recruiters are searching for that magic unicorn.

Also known as the full-stack developer.

But, the problem is, that it's spelled so

many ways, though sometimes it's hyphenated, sometimes it's spaced.

Let's just go head and look for it.

So first if we come in here and we type full-stack.

Cool, it matches.

But what if the cover letter was written a little bit differently right?

What if they didn't hyphenate it?

What if they said full stack?

Okay, so now we're not matching.

Yikes, now what?

Well the good news is that there's metacharacters that

can help explain what we're looking for.

So let's add one.

I'll show you this one first.

There's a character, the period, or the dot and it means any character.

So let's go in here and we'll remove this, and we'll search for any character.

Cool. So now it's finding full stack and if we

put in here, we put in the hyphen, it's also still matching on the full-stack.

But, what happens if we concatenate those words?

Let's get rid of this, so it's fullstack like that.

[SOUND] Wwe're not matching again.

Now what do we do?

Well, there's another metacharacter, and it's an asterisk, or

a star, and it means one or more of these.

So let's go ahead and try that.

So we'll say .*, so with the asterisk there also.

So, it also looks like that will now handle multiple spaces

cuz it's saying any character and it's also doing that.

It looks like we might be over-matching.

What if I did this?

I am full of baloney and

I eat pancakes by the stack.

If this starts jumping around here, you can just kinda grab this and

make it go back.

CSS problem.

But you know that cuz you're full stack.

See that's matching that completely and that is totally not what we want.

So, there are really only a couple of characters that we'd allow in there.

And for that, we'd build what is known as a character class.

Character classes are defined by using square brackets.

And then you put any characters that you want to be allowed inside there.

So, let's see.

We want to have a space and a dash.

Okay?

Cool. So, now we're not matching anymore.

So, let's go ahead and let's bring that back.

Let's say.

So that works, and that works, and if we did something like this, it still works.

But, it's just those two and if I put anything else in there, it doesn't work.

Awesome.

So the character class is nice.

I can put any sort of letter that I wanna match in there, right.

So abcdefg and there you see that it's matching any one of those letters.

You obviously don't wanna type that out each time.

So there's a great thing called ranges.

So inside of the square brackets,

if I do a-z, that would be all of the letters between a and z.

You'll notice that some of the letters that aren't being highlights, so

you can, actually it's case sensitive.

So if I do A through Z or

a through z, there we go, and let's go ahead and put that * back.

There we go, and you'll see that now instead of highlight each letter,

it's highlight each word,

because again, that's zero or more matches is what the star means.

So that is saying, attempt to match every one or

more characters that match uppercase A through Z, or lowercase a through z.

Now, basically that is just saying match all the characters in a word, right?

Like, ignore white space and special character.

Well, guess what, there's a better way to state that.

So if you just say \w*.

There we go.

That's a shortcut for word.

So you're starting to see why regular expressions are hard to read.

They're special metacharacters that would make no sense at all before

you read them or seen them.

I mean, what the heck is \w*?

You should not expect to look at one of these expressions and

expect to know what it's doing, especially right off the bat.

The trick is knowing that it's okay to not know.

I know a few Perl programmers that can write gnarly regexes without documentation

but literally every other programmer I've worked with,

works with the documentation up.

So, let's pop one up.

I'm gonna use the Java documentation.

It's in the teacher's notes.

This is the pattern class.

And if we scroll down here,

there's a nice listing here of all the different constructs.

Okay, so here's the character classes that we were just playing with.

Okay, here's a cool one here.

It says negation.

So it looks like there's a caret at the front.

So let's go ahead and flip back to our.

So we'll say highlight everything that isn't a character based in a word.

Nice. Now it's highlighting all the non-word

characters.

Awesome.

So the caret at the front inside a of character class means not.

Okay, so let's flip back.

Okay, so here's some predefined character classes.

Okay.

Here's the \w that we saw.

A word character, a through z.

Lowercase, uppercase.

Underscore and 0 through 9.

That's something that we didn't think about in ours.

So the \w there, the predefined character class, is great.

Oh look, there's for one for what we were just trying to say.

A non-word character and that can be shortened to uppercase W.

So, if we come back here and just say \W, we get the same thing.

I also saw that we could work with numbers in that documentation.

Why don't we change our example up a bit?

One quick case I can think of is, let's say we have a website with a purchase form

and it's based on the United States and

they're not gonna do shipping outside of the country.

So, let's use a US based zip code.

And those are five digits.

So, let's go ahead and we'll put this is our number up here, 90210.

So remember that we can do ranges, right.

So we got 0 through 9.

Cool. So that's finding each one.

Let's say that we wanted to find zero or more repeating numbers.

We would do the star right?

Cool.

Now notice how it changed all green.

Now that means that the entire pattern is matched.

So, I saw on those dots when we were back there that

there is also one instead of zero through nine, we have \d for digit.

Cool.

Now there is a bit of a problem.

What if there are fewer numbers, I mean, like this, right?

902.

That is not a valid zip code, but we're saying that it is.

Well, guess what, you can specify that.

It uses curly braces to be a quantifier.

So, what we really wanna have, is we wanna say 5 digits.

So now, we'll see that it's not matching, but if I add five digits, it does, and

if I add more, it matches just those five.

I think that we have a working validator.

So let's go ahead and do a real quick look on how we can do this in Java.

I've got a workspace link in the teacher's notes.

Okay, so we've imported one of those consoles and we're gonna go ahead and

say String zipCode.

Console.readLine.

We're gonna take input from that saying, Enter your zipcode.

And if the zip code, which is a string.

Now all strings have a property on them called matches.

So we're gonna say matches and

that parameter that we pass it is a regular expression.

So let's go ahead and let's say slash d, curly brace, for the quantifier five.

So anytime that there are five.

Now there's something that we need to know here.

This slash-d actually means something in JAVA, that means, escape d.

But, we don't want that.

We want the regular expression, so we need to double escape.

It's a little big ugly, right?

So what we're saying is actually write a backslash.

Don't try to do the special character in JAVA.

Does that make sense?

Cuz we are writing in the regular expression language and

we need to actually just write a backslash, which is an escape character.

Okay.

So we'll say system.out.printf and

we'll say this is a valid zip code, right?

Because it's coming in.

And I'll do a new one.

And then we'll pass on the zip code.

So that's gonna replace this %s here.

And because the matches will return true if it is.

And then otherwise, of course, we will just copy this.

And we'll say, is not a valid zip code.

Okay, so let's go ahead and we'll run that.

Again, that run statement, bring this up a little bit.

Run statement is clear,

and we're gonna join a couple of commands together.

The file's called Reggie.

And we'll start it, java Reggie.

So we'll clear the screen, compile and then run the program.

So let's enter a valid zip code, or an invalid one first.

So it'll say 902. And it says 902 is not a valid zip code.

So this matches up here.

It returned false.

So if false, and then it came and fell through there.

So let's do that again.

90210, it's a valid zip code.

Awesome.

All right, what if we put some other stuff in there, right?

So let's assume that in our target text here.

Let's say that we prompted for a zip code and the person wrote next door to Dylan

in 90210, I wish.

Now that's not valid,

but we are saying that it is because it is matching down there.

So it's matching on this.

So let's pop over to the dock and see if there's a way to fix this problem.

We only want the text.

So let's scroll down here a little bit.

Oh, there's a thing here called boundary matchers.

So it looks like carrot marks the beginning of the line and

dollar sign marks the end of the line.

Let's go ahead and put that in.

So if we put at the front of our regular expression, let's put a carat.

Awesome. Now it's not matching down here anymore.

Cool.

So let's go ahead and we can get rid of the front of the line, so

we are saying it must start with that.

Okay, with the trailing garbage, it still matches.

So let's put that end of line marker, which was the dollar sign at the end here.

Awesome.

Now it doesn't match, but

if we take off this junk in the trunk, boom, we got it again.

Great.

Now I wanna point out that you're not going crazy.

We did in the past, just the recent past, use that carat symbol to make it mean NOT.

And that was inside of the character class.

And that only works as the first character in the character class.

Okay? It's one of those confusing things.

And context matters when reading regular expressions.

So let's read it.

The line starts with five digits and then the line ends.

Perfect.

Oh, one more thing.

The US zipcode pattern also allows for

a four digit block of numbers after a hyphen.

It helps to describe the geographic segment.

It's optional.

But, right now, if somebody used that, let's say that they added that.

It would fail.

So let's help it pass.

So, that's a dash and then four more digits, right?

Cool, so it's matching.

But now our original zip code doesn't.

We want that last bit to be optional.

Now, of course there is a way to stick at that.

So, if you wanna group the optional bits by wrapping that in a parenthesis and

we follow that with a question mark.

So let's put the matcher back up there.

So, we're gonna wrap this in parentheses and follow it with a question mark.

So that says this grouping here is optional, okay?

So if we get rid of this.

It still works, and this also matches.

Cool, so let's pop that back in our program.

Copy that.

I'm gonna come over to here.

Zip code matches that.

And remember we need to escape our backslashes.

Cool. So let's run it again and check.

I'm gonna use the up arrow.

90 fails.

And then 90210 5309.

That works.

And also, the one in the middle short, 90210.

Awesome, we have a working US postal code validator.

Now that we've spent all that time building the validator,

this is when the request comes in to support international shipping.

But, don't fret.

Check this out.

Let's go ahead here and we'll search for regular

expression postal code.

So here is a stack overflow posted and let's go ahead and

just take a look at this.

Looking for the ultimate postal code and zip code regex.

I'm looking for something that will cover most and hopefully all of the world.

It's a great idea.

Let's keep on scrolling through here.

Well, here's a good one.

Let's keep on going down.

So here's one.

Here's the official one from Postcode Data.

Try to scroll my screen up without scrolling in there.

So there's a bunch of stuff in here.

This isn't cheating, this is avoiding recreating the wheel, right?

Check this out too.

You can read most of these.

There's a five digit, there's a four digit, there's one with a space,

an optimal space that has capital letters,

there are two capital letters following it.

Pretty great, right?

So, we saw match on the string object.

Let's look at extracting some data.

So first, let's show of another method on the string class.

It's called split.

So, let's get back to that original problem where were parsing information for

a recruiter.

Let's pretend that we were writing a screen scraper and

we wanted to use what was on the website under the freeform skills section.

Let's assume that we had something on a page

that said JavaScript, HTML, CSS and JAVA.

So, what Split is going to do for us is to return the values split apart

by the regular expression that we wanna provide.

So here, we wanna split on things that aren't word characters, right?

We also wanna match on one or more of those non-word characters.

So that means we need to not use the asterisk symbol, which means zero or more.

We actually wanna match on one or more.

So, the not word, we wanna say not words where there are one or more of those.

Okay?

Awesome, that looks good.

So, first things first.

Let's pop back over, and let's just hardcode this zipcode, to be 90210,

so that will always pass.

We don't need the prompt there anymore.

And let's go ahead and let's add the skills.

So we'll say string skills is equal to

JavaScript, HTML, CSS and Java.

Java and JavaScript are different things.

And we'll say for each of the skills in

skills.split.

And again, that takes a regular expression.

And the regular expression that we used on the other side was not words.

More than one of the, right?

And we've gotta remember to escape this.

Okay?

So, say for each one of those skills, so that returns an array.

We can just go ahead and say, system.out.printf.

And we'll say skill.

S and we'll do a new line.

And then we'll print out the skill, each one of the skills.

So it's just gonna loop through each of those values and then array.

Let's go ahead and run that code again.

Okay, cool.

Awesome.

So it split on the comma space.

Cool, right?

Pretty impressive and nice for a defined separator, but

we can do a little bit better.

What if our skills actually looked like this.

And Java.

Oh, now and is gonna be in the results.

See, if you look down here, see and is still gonna show up there.

So let's see if we can get rid of that, right?

So we're gonna do an optional and.

With one or more words there.

Optionally.

Cool, so let's go ahead and pop that over.

And of course, escape them.

Let's make sure the and

is [INAUDIBLE.] Oh, got to put it in here.

Great, it still works, and if somebody was to do this and get rid of that.

There you go.

Who gives a split about an Oxford comma anyways, right?

So split is a good way to extract a somewhat formatted text using a Regex.

But there's even a more powerful way.

One of the problems I have when writing scripts for courses or

workshops, is it's often easier to write something than it is to say something.

Now, personally, I end up swallowing words that have the sh sound in them.

So the fewer of those that I can attempt to say, the better for all of us, right?

So, I'd like to review the words that I've written, and

then find some helpful synonyms before attempting to speak.

So let's find my shushes using a Regex.

Okay? So I'm gonna copy some text here

that I have.

And paste it in here.

And I'll now bring this down.

So it says procrastination is surely not the destination.

Should we talk about shiny things?

So the key is probably to find the noises.

So let's introduce the logical operator or.

So s h from the shiny things or should.

Or with a single pipe ti, from procrastination or destination.

Or the su from surely.

Cool, so that will find the matches, but

I actually really want the whole word so I can find synonyms.

Hm. I know.

Let's wrap it in word characters.

So we need to wrap the middle bit in parentheses,

so it's clear what we're actually ordering.

So we're gonna wrap these in parentheses.

And then we're gonna say, any word character before that.

One or more word characters before that.

Or after that.

So notice how there's two underlines, each underneath each of the words.

That's because the parentheses create what is known as a capturing group.

If we wanted, we could extract those, however, we won't extract the whole word.

So, let's wrap the whole thing in parentheses.

Okay, so let's go and extract these words.

Let's, Copy this, Into Java.

And we'll say,

bring this down a little bit.

SAY String.

Script.

Up here, I've imported pattern.

So, we'll say pattern.

And then we'll just make a new variable called pattern.

And pattern has a static method on it called compile.

And that's where you pass in your Regex.

So we're gonna pick this Regex.

And again, we are gonna escape those w's.

Okay, so let's loop each word that is found.

So there's a helper class,

a great little helper class, that helps us keep track of what was matched.

So, it's the thing called matcher.

and, it keeps state.

So we'll say pattern.matcher,

and matcher takes the text that's going to be worked on.

So you could reuse this thing.

So, we're going to pass the script, and we're going to loop, and we're going to

say matcher.find, and this will return true if there's a pattern that's matched.

And it will also move the state inside of the matcher object

to the next found place.

So, what we'll want, is we'll

say system.out.printf("%s is

a shushy word because of For set S.

Okay, so matcher has, each time it does a find,

it's going to come back and there's a method called group.

And group, if you do group zero, it will return the whole match,

everything that is there.

But if you do group one, it will find the first set of parenthesis.

So the first set of parenthesis is what we want.

So we want whatever the word was.

It was a shushy word, because of.

And then remember we have two sets of parenthesis in our statement here, right?

We have the outside parenthesis, that's one.

And then we have the inside, and that's two.

So let's go ahead and see if we got it.

Let's run that script again.

I'll bring him back up.

Cool. So procrastination is a shushy word.

And surely is a shushy word, awesome.

Perfect, we found it.

So surely capturing shells show how beneficial regular expressions

actually are.

Whoa. You see why I need it?

Hey, this actually gives me a chance to show you a couple of things.

First off, let me copy from my script what I actually said.

Surely capturing shushes.

Okay. So

it looks like there's a couple things that we missed here.

So we're definitely missing the ci.

And looks like there's a tu and an si of Expressions.

Great.

So, notice how it's not catching that surely at the front.

And that's because this is case sensitive.

Unless you tell it not to be, right?

So if I click here, if I click this ignore case.

You will see what this actually does, is it pops this question mark I at the front,

and that's a way of sending a flag.

Specifically into your regular expression.

And you can do that.

But as you can imagine, probably, Java has a more specific way of doing that.

So let's go ahead and flip this over.

And the second parameter is flags.

And so there is a on pattern.

There is a constant called, case insensitive.

Cool.

I'm gonna go ahead and copy my script back over.

We'll change this script here, and we'll give this a run.

There surely is counter with a capital S there.

All right, now I hope that these regular expressions are starting to look a little

more sensible now, and

a lot less like ancient hieroglyphics or really bizarre emoticons.

Make sure you check out the teacher notes, if you are hungry for more.

Hope you had a good time.

Awesome.

I'm very glad we took that time to delve deeper into regular expressions.

Now, I'm certain you'll encounter them, and now you're armed with information,

and they just start looking a lot less intimidating.

Again, don't feel like you need to fully understand these.

You'll get better with practice, and they are definitely one of those concepts that

really clicks when you need to use them.

If you like this forma,t and would like to see more like this, please speak up in

the forum about what you'd like to see, and we'll do our best to make it happen.

I value your feedback and suggestions, and

am very excited to build the content you want and need.

Thanks for hanging out, and see you soon.