RegEx Tester

A regular expression is a sequence of characters defining a search pattern used to find, replace, or validate text. JavaScript relies on the ECMAScript RegExp engine, supporting modern features like Unicode properties and lookbehind assertions. If you are formatting variable lists to camelCase or kebab-case before matching them, convert them with our Case Converter. Here is how to create a regular expression in JS:

// Literal notation (compiled once when the script is loaded)
const literalRegex = /\b[A-Za-z]+\b/g;

// Constructor function (compiled at runtime, useful for dynamic inputs)
const dynamicRegex = new RegExp("\\b[A-Za-z]+\\b", "g");

Flags are single-character modifiers appended to regular expressions that alter how the matching engine operates. Common flags include global search, case insensitivity, multiline matches, and unicode evaluation. If you are extracting encoded variables from test strings, you can verify their values using our Base64 Encoder / Decoder. Here are the common flags:

/* JavaScript RegExp Flag Parameters */
const regex = /pattern/gimsuy;
// g -> global (find all matches rather than stopping at the first)
// i -> case-insensitive (ignore upper/lower character differences)
// m -> multiline (makes ^ and $ match start/end of individual lines)

Parentheses define capture groups, which allow you to extract specific segments of a matched string. The matching engine remembers these subpatterns and returns them in a structured array. If you are converting tabular row outputs into structured databases, parse them using our CSV to JSON Converter. Here is how to extract capture group elements:

const logLine = "2026-06-02 [INFO] Server started";
const regex = /(\d{4}-\d{2}-\d{2})\s+\[([A-Z]+)\]/;
const match = regex.exec(logLine);

// match[0] -> "2026-06-02 [INFO]" (Full Match)
// match[1] -> "2026-06-02" (First Capture Group)
// match[2] -> "INFO" (Second Capture Group)

Assertions are zero-width matches that check if a pattern is preceded or followed by another pattern, without including it in the match result. Lookbehinds allow you to check characters before the match, which is useful for validating currency codes or tag identifiers. If you need to analyze JWT header properties after finding them in text blocks, try our JWT Decoder. Here are lookbehind examples:

// Positive lookbehind (?<=): Match digits only if preceded by "$"
const priceRegex = /(?<=\$)\d+/;
"$100".match(priceRegex); // Matches "100"

// Negative lookbehind (?<!): Match digits only if not preceded by "$"
const numberRegex = /(?<!\$)\b\d+\b/;
"100 USD".match(numberRegex); // Matches "100"

Regular expressions are commonly used to validate inputs like emails, dates, and numbers. It is best to test validation patterns against multiple inputs before deploying them to production. If you are writing user guide documentation for these patterns, convert them with our Markdown to HTML Converter. Here are common validation patterns:

// Email address validation pattern
const emailRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;

// Numeric integer validation pattern
const integerRegex = /^-?\d+$/;

// Standard YYYY-MM-DD date validation pattern
const dateRegex = /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/;

Catastrophic backtracking occurs when a pattern containing nested quantifiers is run against non-matching strings, causing exponential evaluation steps. This can freeze browser tabs or crash servers. If you want to filter out duplicate rows or clean server log blocks before parsing them, try our Duplicate Line Remover. Here is an example of an insecure pattern:

// Insecure pattern vulnerable to backtracking
const badPattern = /^(a+)+$/;

// A long string of "aaaa...aab" causes exponential evaluations
badPattern.test("aaaaaaaaaaaaaaaaaaaaaaaaab");