Explore JavaScript regular expressions: learn about regex history, create patterns with special characters, parse data, and match passwords/emails, gaining comprehensive text processing skills.

bite_size_js.tar.gz

RunNode12

Regular Expressions, also known as Regex, come in handy in a multitude of text processing scenarios. Regex defines a search pattern using symbols and allows you to find matches within strings. The applications of this span from software engineering to data science and beyond.

In this course, you will begin with an introduction to regex, its history, and various types of regular expressions. 

You will then learn how to create your own regular expressions using various techniques and special characters. In the latter half of the course, you will explore RegExp Objects, how to parse data, turn phrases into an array of strings, and lastly password and email pattern matching.

By the end of this course, you will be a regular expressions expert.

JavaScript Regular Expressions in Detail

# Regular expression to match the protocol

This part is easy. There aren’t that many protocols around, and since our testing strings are quite simple, we can say a protocol is either the string http, https, or ftp, followed by the “://” portion. This is how we can write that in a RegExp:


```javascript
/(https?|ftp):\/\//g
```
To double-check what we’ve seen so far (and the new part with the OR operator), let’s break it down:


- We’re matching both *http* and *https* with the addition of the *?* character after *https* (essentially making the last *“s”* optional). 

- We’re using the **OR** operator (that **|** character) to let the parser know we’re good with either side of the expressions inside the parenthesis. In other words, groups can contain subexpressions inside them, and you can let the parser know you’re looking for one of many different options inside a string.

- Finally, we’re matching the “**://**” portion of the protocol by escaping the slash because, if you remember correctly, that is the character we use to delimit the start and end of the literal regular expression's syntax in JavaScript (and other languages as well). So if we don’t escape them, the parser will not really understand them as part of the matching string.

# Regular expression to match the hostname

Now the hostname should have an optional *www*, the name of your server, and a *.com* to complete it (hostnames are a bit more complicated than that, but, for the sake of simplicity, we’re keeping the list of conditions to a minimum).
So, an expression like the following might help:

```javascript
/(www\.)?([a-z-]+)\.com/g
```
Again, breaking things down:


- The optional *www* is represented by making the first group optional (remember that adding the ? after it will let the parser know we’re looking for either one or zero instances of that group).

- The server name is represented by the character class at the middle. We’re allowing any character from a to z and dashes (-).
- The final mandatory *.com* is represented by the ending, *\.com*.

Notice how we had to escape the dot in both places. If we hadn’t, the expression would’ve worked anyway because the dot, as you might remember, is a wildcard for almost any character. So, without escaping it, the following string would’ve also matched our expressions (which is something we don’t want): *wwwmyhostcom*.

Look at the following screenshot and see how regex101.com helps you understand which parts of your expression match different parts of your testing strings. 



Look at how the regular expressions are written in JavaScript to match the protocol and hostname of a URL. 

The Beginning of Regular Expressions

The Anatomy of Regular Expressions

The RegExp Object

Thinking in Regular Expressions

Regular Expressions in the Wild

Wrapping Up

Special Characters: Matching the Protocol and Hostname

Regular expression to match the protocol