Regular expressions in programming: practical examples for JavaScript

3 min reading
11 August 2016
Regular expressions in programming: practical examples for JavaScript
Regular expressions in programming: practical examples for JavaScript


Among many other things, learning to program involves memorizing expressions and steps that allow you to carry out simple and practical actions. A good comparison would be the typical keyboard shortcuts that enable you to use a simple combination of keys to go to the explorer, close the browser, search for a program and so on. In some programming languages, regular expressions serve to detect patterns in different text strings. With a single step, these regular expressions make programmers’ work much easier. 

A very simple example is using a regular expression to verify whether the information on a form filled out by users is correct or not. A short form may be used to collect the customers’ first and last names and contact telephone number, but some customers may fail to correctly complete this last field. The fastest way to check this is through a regular expression. Developers who regularly use Perl for their projects are very familiar with these tools and can do this thanks to simple shortcuts.

But Perl programmers are not the only developers who can exploit the benefits of regular expressions. JavaScript professionals can also use them, and especially to make specific verifications in different text strings based on a pattern that can be summarized in an open expression. Analytical tools such as Google Analytics can also be used.

This is how regular expressions are used in JavaScript

Regular expressions use characters and metacharacters to openly define specific patterns in text strings. By combining these characters with others in a particular way, you can search for items or specific elements to be extracted from these strings in order to search or manipulate the text (identifiers, emails…). In the case of JavaScript, there are two types of regular expressions:

●      Regular expressions via a literal string to find a pattern: these use the object constructor RegExp. A RegExp literal is created using this expression: var re = /regular expression/;. The regular expression pattern appears between the opening and closing backslashes, a structure that tends to be habitual and obligatory.

●      Regular expressions applied to several strings: expReg.test(string). If there’s a match between the expression and a possible pattern, it returns true; and false if not.

Some special elements for making regular expressions in JavaScript:

●      ^: the element must be matched from the start of the string.

●      [A-Z]: any character between capital A and capital Z.

●      {1,2}: one or two characters.

●      \s: a blank space.

●      \d: one digit.

●      {4}: four digits.

●      \s: a blank space.

●      ([B-D]|[F-H]|[J-N]|[P-T]|[V-Z]): any character between capital B and capital Z, except vowels.

●      {3}: three characters.

●      $: the element must be matched to the end of the string.

Specific cases of use of regular expressions

Regular expressions are often used to detect whether there is a specific sequence of letters, words or numbers in a particular string. This can be done by using a simple regular expression:

var reg = /javascript/;
 “This is javaScript” language.match(reg);
 // returns an array of an element [“javascript”],
as there is an element with that specific sequence of letters within the string. If the words “javaScript” do not appear in the string, it will return a null element.

Sometimes the element if is used to find true or false matches from a combination of characters and words (expressions) in a complete string:

if (“This is javaScript” language”.match(/javascript/) {
    // This will return true because the javaScript element appears in the string.
 if (“This is javaScript” language”.match(/javascript/) {
    // This will return false because the javaScript element doesn’t appear in the string.

Using the element linked to the search for digits, regular expressions can check whether a string has a specific digit, and can even be programmed to detect combinations and repetitions of series of digits within one or several text strings:

–       Search for a specific digit in a text chain: in this particular case, the programmer searches to see whether the text string contains the number 2. As it does, the regular expression logically returns a [“2”].

“This number is a 2”.match(/\d/); // Returns a [“2”]

–       Regular expressions are also able to detect the repetition of one or several digits within a text string or a specific sequence of numbers within the same text string. The only thing you need to do is to repeat the elements \d within the expression, which must be accompanied by the symbol / at the beginning and end:

“This number is 242”.match(/\d\d\d/);   // Returns [“242”] because there is an expression containing 3 consecutive digits within this string.

–       To search for digits in different text strings:

/\d{3}/       Search 3 digits in the string
/\d{1,5}/    Search for between 1 and 5 digits in the string.
/\d{2,}/      Search for 2 or more digits in the string.

Here are just a few specific examples with this last regular expression: in the first example, the expression allows you to search for a maximum of two digits in a particular text string (in this case, “1234”), so it returns the element [“12”]; in the second case, the search is for between one and three digits, so it returns [“123”]; and in the third case, the expression searches for between three and ten digits, so it returns four, the full text string: [“1234”]. 




It may interest you