Regex Tester

AabiTech's Regex Tester is a JavaScript regex tester. The tool uses the browser's native JavaScript RegExp implementation rather than pretending that all regular-expression engines behave identically.

This matters because regular-expression syntax can vary between programming languages and engines. A pattern intended for JavaScript should be tested with JavaScript-compatible syntax before it is placed into browser code or a Node.js application.

JavaScript supports features including character classes, quantifiers, capturing groups, named capturing groups, backreferences, lookahead and lookbehind assertions, Unicode features and several regex flags.

If your production code uses another regex flavor such as PCRE or Python's re engine, verify that the syntax is compatible before using the pattern there.

Finding a match is often only the first step. Capture groups allow a regex to identify useful parts of a larger match. For example, the pattern (\d{4})-(\d{2})-(\d{2}) can capture the year, month and day separately from an ISO-style date.

AabiTech displays capture groups for individual matches so you can see exactly which part of the pattern produced each captured value.

JavaScript also supports named capture groups. A pattern such as (?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2}) gives the captured values meaningful names instead of requiring you to remember only their numeric positions.

Named groups are especially useful when a regular expression extracts structured information from dates, URLs, logs, identifiers or other semi-structured text.

Regex flags change how a JavaScript regular expression searches and interprets text. AabiTech provides the commonly used JavaScript flags directly in the tester.

• g — global matching, allowing the expression to find multiple matches.
• i — case-insensitive matching.
• m — multiline behavior for line boundaries.
• s — allows the dot character to match line terminators.
• u — Unicode-aware matching.
• y — sticky matching from the current position.
• d — provides match indices where supported by the browser.
• v — enables the newer JavaScript Unicode Sets behavior where supported.

For example, use the g flag when you want to find every occurrence of a pattern instead of stopping at the first match. Use i when letter case should not affect matching.

A regex can appear to work while still accepting incorrect input or rejecting valid input. Test cases make it easier to check both sides of a validation rule.

Use the AabiTech Test Cases area to add sample values that should match and values that should not match. Each case is evaluated against the current JavaScript regular expression and reported as passed or failed.

For an email-style expression, for example, you might test student@example.com as a value that should match and not-an-email as a value that should not match.

Testing positive, negative and edge-case examples is especially useful before moving a regular expression into form validation, data processing or application code.

Regular expressions are useful for transforming text as well as finding it. AabiTech's Replace mode lets you preview the result of replacing regex matches with replacement text.

JavaScript replacement patterns can reference capture groups using tokens such as $1 and $2. The complete match can be referenced with $&, while named groups can be referenced with $<name>.

For example, the pattern (\d{4})-(\d{2})-(\d{2}) can be combined with the replacement $2/$3/$1 to transform an ISO-style date into month/day/year order.

Previewing replacement output before putting it into application code helps catch incorrect capture-group numbering and replacement syntax.

Common regular-expression tasks include finding email-like addresses, phone numbers, URLs, dates, IP addresses, hashtags, usernames and numbers inside larger text.

AabiTech includes ready-made examples for several of these tasks so you can start with a working pattern and modify it for your own requirements.

For example, a simple email-style pattern can be used to locate addresses inside a text sample, while a date pattern such as \b\d{4}-\d{2}-\d{2}\b can locate dates in YYYY-MM-DD format.

These examples are intended for testing and learning. A regular expression that works for one application's input rules may not be sufficient for every possible real-world value, so always test patterns against the data your application actually receives.

Regular expressions are commonly used for two related jobs: validation and extraction.

Validation checks whether an entire value follows a required format. For example, a pattern anchored with ^ and $ can be used to test whether a username or slug follows a defined structure.

Extraction searches a larger body of text and identifies useful pieces such as email addresses, dates, URLs, order identifiers or log values. The global flag is often useful when multiple values need to be found.

The Regex Tester supports both workflows by providing match highlighting, match counts, capture groups, match positions and reusable test cases.

Regex testing can involve source code, logs, identifiers or other text that you may not want to upload to a remote service. AabiTech performs regex processing in your browser for this tool, so the pattern and test text do not need to be sent to AabiTech's server for matching.

This browser-based approach also avoids a server round trip for normal regex testing and keeps the interaction responsive.

Although browser processing reduces the need to transmit your input, you should still follow your organization's data-handling policies when working with sensitive information.