JavaScript RegEx
Tags: javascript, regex, codenewbie
Published: 2020-05-16 22:26:39

One of the most powerful tools in JavaScript is the ability to parse, extract, and validate data easily and efficiently using regular expressions (*regex*). While using regular expressions may seem a bit confusing and daunting at first, it’s a highly valuable and useful skill to master.

### Regular Expressions Defined
Regular expressions are a pattern of characters that are used to construct a search. The defined sequence of characters describes what you are looking for. This can be anything from a single character to a complex pattern and may also include special characters. Using regular expressions we can not only search for a defined pattern, we can execute text replacement operations. 

In JavaScript, a regular expression literal defines the desired pattern between two forward slashes.

`let re = /abc/`

This is most commonly how you will see regular expressions declared. The less common way is to use the regex constructor function.

`let re = new RegExp(‘abc’)`

### Regex Modifiers
There are many modifiers that help make regular expressions more succinct. The following three modifiers are highly useful for even the most basic regular expressions.

**i**: case-insensitive matching
>let str = “I am Sam.”
>let re = /sam/i
>*>> Sam*

**g**: global matching
>let str = “I am Sam.”
>let re = /am/g
>*>> am, am*

**m**: multiline matching
>let str = “\nI am Sam. \nSam I am.”
>let re = /I/m
>*>> I*

### Regex Brackets
Brackets allow us to specify a range of characters to be included or excluded from our search. This works the same way with both letters and numbers.

**Example: let str = “There are 8 planets”**

**[abc]**: find any characters included within the brackets
>let re = /[a]/g
>*>> a, a*

**[^abc]**: find any characters excluded from the brackets
>let re = /[^es]/gi
>*>> T, h, r, a, r, 8, p, l, a, n, t*

**[0-9]**: find any number included within the brackets
>let re = /[8]/g
>*>> 8*

**[^0-9]**: find any non-number within the brackets (numbers are excluded)
>let re = /[^8]/g
>*>> T, h, e, r, e, a, r, e, p, l, a, n, e, t, s*

### Regex Metacharacters
Next, we will take a look at regex metacharacters. These are characters with special meaning that help to quickly create specific and effective search patterns. Because there are so many metacharacters, we will only explore a few basic examples to get the gist of how they work.

**Example: let str = “Feeling 90%”**

**w**: find a word character
>let re = /w/g
>*>> F, e, e, l, i, n, g, 9, 0*

**W**: find a non-word character
>let re = /W/g
>*>> %*

**d**: find a digit
>let re = /d/g
>*>> 9, 0*

**D**: find a non-digit character
>let re = /D/g
>*>> F, e, e, l, i, n, g, %*

**b**: find a match at the beginning or end of a word
**B**: find a match *not* at the beginning or end of a word
**s**: find a whitespace character
**S**: find a non-whitespace character
**r**: find a carriage return character
**t**: find a tab character

### Regex Quantifiers
The final aspect of regex that we will look at is quantifiers. Much like metacharacters, quantifiers act as an efficient way to build on our search pattern. 

**Example: let str = “Hello there user121”**

**x+**: finds any string with at least one x
>let re = /e+/g
>*>> e, e, e, e*

**x***: finds any string with 0 or more x’s
>let re = /er*/g
>*>> e, er, e, er*

**x?**: finds any string with 0 or one x
>let re = /1?/g
>*>> , , , , , , , , , , , , , , 1, , 1*

**x{N}**: finds any string with N x’s
>let re = /d{2}/g
>*>> 12*

### Conclusion
Regular expressions are certainly confusing upon first glance. However just like any other programming principle, the more you practice, the more clear using regular expressions will become. Having a sound understanding of the basics of regex is highly valuable for efficiently combing through data and will play a significant role in how you approach this process within your applications. 

When faced with a problem that can be solved using regex, it’s worth investing the time and effort to research which regex metacharacters and quantifiers may provide the best solution. The more you familiarize yourself with what’s possible using regex one problem at a time, the more readily it will come as you continue working with regular expressions. While it has the potential to be a tough nut to crack, feeling comfortable with regex is a worthwhile pursuit.