JavaScript RegExp Syntax Cheat Sheet v1.3.4, PDF Download

JavaScript RegExp Defination

The JavaScript RegExp object explains the patterns of characters. These patterns are used in search, validation, and search and replace functionality in JS programming.

JavaScript RegExp Syntax

// Syntax 
/pattern/modifiers;

//Example
let pattern = /infopediya/i


//

In above example the /infopediya/i is example of JS RegExp.

The /infopediya/ is a pattern and /i is a modifier. we will explain the modifiers in JavaScript RegExp Syntax Cheat Sheet.

How to use JavaScript Regular Expressions?

How to create a pattern using a constructor?

It is easy to create a pattern using the new RegExp(). It creates a new RegExp object.

//Example of the constructor

let pattern = new RegExp("Hello World", "g");
console.log(pattern);

//

Here the pattern variable will give you the ” /Hello World/g ” as output. The new RegExp accepts two parameters the string and modifier.

In the above example ‘ Hello World ‘ is the string pattern and ‘g’ is a modifier given as the parameters to new RegExp().

What are modifiers in regular expressions?

The modifiers add a particular behavior/functionality to the whole pattern.

For example, if we want to search a case-insensitive piece of text in a paragraph then the Case Insensitive flag comes in handy. The symbol for Case Insensitive is ” /i “.

The /hello world/i will match ” Hello World ” as well.

Examples

JavaScript RegExp /g Modifier

//Example 

let sample_text =  'Lorem ipsum dolor sit amet consectetur adipisicing elit. Dolor nisi voluptatibus sequi Lorem soluta possimus dolores libero veritatis iste, saepe esse';


//search 'Lorem' without /g flag
let result1 = sample_text.match(/Lorem/);
console.log(result1);
//Output:["Lorem"]


//now search 'Lorem' with /g flag
let result2 = sample_text.match(/Lorem/g);
console.log(result2);
//Output: ["Lorem", "Lorem"]

JavaScript RegExp /i Modifier

// Example /i

let sample_text =  'Lorem ipsum IPSUM dolor sit amet consectetur adipisicing elit. Dolor nisi voluptatibus sequi Lorem soluta possimus dolores libero veritatis iste, saepe esse';

//search 'Lorem' without /i flag
let result1 = sample_text.match(/ipsum/g);
console.log(result1);
//Output:["ipsum"]


//now search 'Lorem' with /i flag
let result2 = sample_text.match(/ipsum/gi);
console.log(result2);
//Output: ["ipsum", "IPSUM"]

JavaScript RegExp /m Modifier

Note: The /m flage is case sensitive. Use it with /gi to search globally with case insesitive matches.

// Example /m
//  \n shows new line
// $ sign shows ending and ^ sign shows beginning in RegExp.
// we will explain these signs latter here.

let sample_text =  'This is paragraph one.\nThis is paragraph two. Paragraph three';

//each line starts with this
let result1 = sample_text.match(/^This/mg);
console.log(result1);
//Output:["This"]


//each line ends with three
let result2 = sample_text.match(/three$/mg);
console.log(result2);
//Output: []

What are JavaScript Regular Expression Quantifiers?

Quantifiers simply show the quantity. consider the following example.

the @ symbol repeats atleat one time and underscore ( _ ) repeats one or more times.

The @ symbol is required but ( _ ) is optional.

//Example Quantifiers

let email1 = "email@example.com";
let email2 = "email_123_123_123@example.com";

//

Now how to set validation rules for such conditions? The Quantifiers resolve this problem.

JavaScript RegExp [abc] Expression

This expression is used to find any characters given inside the brackets.

You can specify simple characters as [abcd].

you can specify any range as from zero to nine [0-9]. Or from uppercase A to lowercase z [A-z].

// Example [abc] Expression

 let str = "This is a sentence.";
  let pattern = /[T]/g;
  let result = str.match(pattern);

  console.log(result);

// output: ["T"]

//

JavaScript RegExp [^abc] Expression

This expression is used to find any characters accept given inside the brackets.

This is opposite to [abc] Expression.

// Example [^abc] Expression

 let str = "This is a sentence.";
  let pattern = /[^T]/g;
  let result = str.match(pattern);

  console.log(result);

// output: ["h", "i", "s", " ", "i", "s", " ", "a", " ", "s", "e", "n", "t", "e", "n", "c", "e", "."]

//

JavaScript RegExp . Metacharacter

The dot metacharacter is very powerful. it is used to match:

1: Every single character

2: A single character

consider the following example

// Example for dot metacharacter

// Find simple character

  let str = "Get and set values of variables.";
  let pattern = /.et/g;
  let result = str.match(pattern);
  console.log(result);
  //Output: ["Get", "set"]

//OR match every character


  let str = "Get and set values of variables.";
  let pattern = /./g;
  let result = str.match(pattern);
  console.log(result);
  // Output: ["G", "e", "t", " ", "a", "n", "d", " ", "s", "e", "t", " ", "v", "a", "l", "u", "e", "s", " ", "o", "f", " ", "v", "a", "r", "i", "a", "b", "l", "e", "s", "."]

//

List of JavaScript RegExp Metacharacters

Download JavaScript RegExp Syntax Cheat Sheet, the PDF File Here.

References

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp

https://www.w3schools.com/jsref/jsref_obj_regexp.asp

https://regexr.com/