Cheatsheet for the Regex Cheatsheet, Part V: Quantifiers
Tags: beginners, javascript
Published: 2021-05-10 17:52:30

##Intro
I was recently doing a code challenge for a job interview that required me to strip out all nonalphabetic characters. "Ah! I should use Regular Expressions for this!" I thought in triumph, impressed that I even knew what regular expressions _were_. That fleeting moment of glory faded once I decided to brush up on regular expressions and landed on the encouragingly-named [Regular Expressions Cheatsheet](https://cheatography.com/davechild/cheat-sheets/regular-expressions/). I had no idea how to use it!

So, for people like me, here is a *Cheatsheet for the Regular Expressions Cheatsheet, Part V: Quantifiers*

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/952eizrrs8n8c14nbfm3.png)

## What's an Quantifier?
A quantifier finds a sequence of characters to match. It also can be used to find a sequence of expressions to match, but I'm gonna keep it simple here and focus on sequences of characters.

## Anatomy of a regular expression
1. Forward slashes go on either end like so: ``/``something``/``
2. Add ``g`` for "global" at the end to find every instance, like so: ``/``something``/g``
3. Add ``m`` to "multi line" to the beginning/end of each line, not just the beginning/end of each string, like ``/``something``/g`` or ``/``something``/gm``

## Quantifiers

##### ``*`` 0 or more instances of a character
* ``*`` is used in ``/ro*ar/`` to find the following:  
*The lion said <mark>roar</mark> <mark>rooar</mark> <mark>roooar</mark> <mark>roooooooar</mark>!*
* Example on [regex101.com](https://regex101.com/r/KwCm09/1)
* Example in Javascript:
```javascript
let sentence = "The lion said roar rooar roooar roooooooar!";
let regex = /ro*ar/;
let found = sentence.match(regex);
console.log(found); // [
  'roar',
  index: 14,
  input: 'The lion said roar rooar roooar roooooooar!',
  groups: undefined
]
```
---
##### ``+`` 1 or more instances of a character
* ``+`` is used in ``/ro+ar/`` to find the following: 
*The lion said <mark>roar</mark> <mark>rooar</mark> <mark>roooar</mark> <mark>roooooooar</mark>!*
* Example on [regex101.com](https://regex101.com/r/UiZmpm/1)
* Example in Javascript:
```javascript
let sentence = "The lion said roar rooar roooar roooooooar!";
let regex = /ro+ar/;
let found = sentence.match(regex);
console.log(found); // [
  'roar',
  index: 14,
  input: 'The lion said roar rooar roooar roooooooar!',
  groups: undefined
]
```
---
##### ``?`` 0 or 1 instance of a character
* ``?`` is used in ``/ro?ar/`` to find the following: 
*The lion said <mark>roar</mark> rooar roooar roooooooar!*
* Example on [regex101.com](https://regex101.com/r/JQz9UY/1)
* Example in Javascript:
```javascript
let sentence = "The lion said roar rooar roooar roooooooar!";
let regex = /ro?ar/;
let found = sentence.match(regex);
console.log(found); // [
  'roar',
  index: 14,
  input: 'The lion said roar rooar roooar roooooooar!',
  groups: undefined
]
```
---
##### ``{N}`` N instances of a character
* ``{3}`` is used in ``/ro{3}ar/`` to find the following: 
*The lion said roar rooar <mark>roooar</mark> roooooooar!*
* Example on [regex101.com](https://regex101.com/r/VvSgrl/1)
* Example in Javascript:
```javascript
let sentence = "The lion said roar rooar roooar roooooooar!";
let regex = /ro{3}ar/;
let found = sentence.match(regex);
console.log(found); // [
  'roooar',
  index: 25,
  input: 'The lion said roar rooar roooar roooooooar!',
  groups: undefined
]
```
---
##### ``{N,}`` At *least* N instances of a character
* ``{3,}`` is used in ``/ro{3,}ar/`` to find the following: 
*The lion said roar rooar <mark>roooar</mark> 
 <mark>roooooooar</mark>!*
* Example on [regex101.com](https://regex101.com/r/MVVz9H/1)
* Example in Javascript:
```javascript
let sentence = "The lion said roar rooar roooar roooooooar!";
let regex = /ro{3,}ar/;
let found = sentence.match(regex);
console.log(found); // [
  'roooar',
  index: 25,
  input: 'The lion said roar rooar roooar roooooooar!',
  groups: undefined
]
```
---
##### ``{N,M}`` Between N and M instances of a character
* ``{2,4}`` is used in ``/ro{2,4}ar/`` to find the following: 
*The lion said roar <mark>rooar</mark> <mark>roooar</mark> roooooooar!*
* Example on [regex101.com](https://regex101.com/r/lGtayD/3)
* Example in Javascript:
```javascript
let sentence = "The lion said roar rooar roooar roooooooar!";
let regex = /ro{2,4}ar/;
let found = sentence.match(regex);
console.log(found); // [
  'rooar',
  index: 19,
  input: 'The lion said roar rooar roooar roooooooar!',
  groups: undefined
]
```