Understanding Regex Definitions

Regular expressions provide a powerful mechanism for matching patterns within strings. In JavaScript, you can define these patterns using either the RegExp constructor or the literal syntax.

Defining Patterns

The literal syntax is the most concise way to declare a pattern:

const examplePattern = /abc/;

Alternatively, you can use the object-oriented approach:

const dynamicPattern = new RegExp("abc");

Basic Matching

The test() method determines whether a string matches a specific pattern, returning a boolean value. Literal characters within the expression are matched exact as written.

const pattern = /data/;
console.log(pattern.test("big data")); // true
console.log(pattern.test("science"));  // false

For characters that are hard to type directly, such as line breaks or tabs, use escape sequences like \n (newline) or \t (tab).

function checkNewline(input) {
    const pattern = /js\n/;
    return pattern.test(input).toString();
}

Character Classes

Character classes allow you to match one of a set of characters. Defined within brackets [], they simplify complex character requirements.

• [a-z]: Matches any lowercase letter.
• [0-9]: Matches any digit.
• [^0-9]: Negated class; matches any thing that is not a digit.

Shortcuts are also available:

• \d: Equivalent to [0-9].
• \w: Matches alphanumeric characters (plus underscore).
• \D: Non-digit character.

function validatePatterns(str) {
    // Matches a letter followed by a digit
    const pattern1 = /[a-zA-Z][0-9]/;
    // Matches 'A' followed by a non-digit character
    const pattern2 = /A\D/;
    return `${pattern1.test(str)},${pattern2.test(str)}`;
}

Repetition and Quantifiers

Quantifiers specify how many times a character or group can appear.

• {n}: Exactly n times.
• {n,m}: Between n and m times.
• +: At least once ({1,}).
• *: Zero or more times ({0,}).
• ?: Zero or one time ({0,1}).

To match literal special characters like + or ?, you must escape them with a backslash \.

function checkQuantifiers(str) {
    const p1 = /\?{1,}/;      // ? at least once
    const p2 = /\+{3}/;      // + exactly three times
    const p3 = /\{\}{1,2}/;   // {} appearing 1 to 2 times
    const p4 = /\\{0,1}/;    // \ appearing 0 or 1 time
    return `${p1.test(str)},${p2.test(str)},${p3.test(str)},${p4.test(str)}`;
}

Alternation and Grouping

Use the pipe operator | for OR logic, and parentheses () to group elements for logical units.

function matchPatterns(input) {
    // Matches 17 digits followed by a digit or X
    const p1 = /[0-9]{17}([0-9]|X)/;
    // Matches (23 or 24) followed by 4 digits
    const p2 = /(23|24)[0-9]{4}/;
    // Matches specific area codes
    const p3 = /(010|020|021|022|023|024|025|027|028|029)/;
    return `${p1.test(input)},${p2.test(input)},${p3.test(input)}`;
}

References and Boundaries

Capturing groups can be referenced later in the expression using back-references (e.g., \1, \2), which ensures that the repeated portion matches the exact content found in the first capture.

Boundary assertions allow for precise matching:

• ^: Start of string.
• $: End of string.
• \b: Word boundary.

function matchWord(text) {
    const pattern = /^js\b/; // Starts with 'js' as a full word
    return pattern.test(text).toString();
}

Modifiers

Modifiers change the behavier of the engine:

• i: Case-insensitive.
• g: Global matching (find all instances).
• m: Multiline mode.

function findShellWords(text) {
    const pattern = /\bshell\b/ig;
    return text.match(pattern);
}

Regex String Methods

Common string methods like replace() can leverage regular expressions for advanced data cleaning:

function scrubScores(report) {
    // Removes all digits globally
    const regex = /[0-9]+/g;
    return report.replace(regex, "");
}