Test, validate, and debug regular expressions instantly with real-time match highlighting.
Supported JavaScript flags include g, i, m, s, u, y, and d. Invalid flags or syntax are reported without crashing the tester.
Tested JavaScript regex examples with matching and non-matching inputs.
/^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$/Checks for a practical email shape with one @ and a dot in the domain.
Matches: dev@example.com
Does not match: dev@example
Limitations: This is intentionally pragmatic, not a complete RFC email parser; it does not verify that the address exists.
/^https?:\/\/[^\s]+$/iRequires an HTTP or HTTPS scheme followed by at least one non-space character.
Matches: https://example.com/docs?q=1
Does not match: example.com/docs
Limitations: It does not validate every URL rule or confirm that the host is reachable.
/^(?:(?:25[0-5]|2[0-4]\d|1?\d?\d)\.){3}(?:25[0-5]|2[0-4]\d|1?\d?\d)$/Validates four decimal octets, each in the range 0–255.
Matches: 192.168.1.10
Does not match: 192.168.1.300
Limitations: It does not distinguish private, loopback, multicast, or reserved address ranges.
/^(?:[0-9A-Fa-f]{1,4}:){7}[0-9A-Fa-f]{1,4}$/Matches the fully expanded eight-group IPv6 notation.
Matches: 2001:0db8:0000:0000:0000:ff00:0042:8329
Does not match: 2001:db8::1
Limitations: This educational pattern does not support compressed (::), IPv4-mapped, or zone-indexed IPv6 forms.
/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iChecks the UUID layout plus the version 4 and RFC variant bits.
Matches: 550e8400-e29b-41d4-a716-446655440000
Does not match: 550e8400-e29b-11d4-a716-446655440000
Limitations: It validates format and bits only; it cannot prove uniqueness or how the UUID was generated.
/^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/iAccepts CSS-style three- or six-digit hexadecimal colors with a leading #.
Matches: #0ea5e9
Does not match: 0ea5e9
Limitations: It excludes alpha forms such as #RRGGBBAA and functional color notation.
/^\d{4}-\d{2}-\d{2}$/Checks the YYYY-MM-DD shape used by ISO-style dates.
Matches: 2026-10-11
Does not match: 11/10/2026
Limitations: It checks shape, not calendar validity; values such as 2026-99-99 still match.
/^(?:[01]\d|2[0-3]):[0-5]\d$/Matches hours from 00–23 and minutes from 00–59 in HH:MM format.
Matches: 23:45
Does not match: 24:00
Limitations: Seconds, time zones, and leap seconds are not included.
/^[+-]?\d+$/Accepts an optional sign followed by one or more decimal digits.
Matches: -42
Does not match: 3.14
Limitations: It does not enforce a numeric range and accepts leading zeroes.
/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)$/Matches signed whole numbers and decimal values such as 12.5 or .5.
Matches: -12.50
Does not match: 1,000.00
Limitations: Scientific notation, locale separators, and numeric range are not supported.
/^[a-z0-9]+(?:-[a-z0-9]+)*$/Allows lowercase words or numbers separated by single hyphens.
Matches: regex-cheat-sheet
Does not match: Regex Cheat Sheet
Limitations: Whether a slug is unique or appropriate for a specific route must be checked separately.
/^[A-Za-z0-9]+$/Requires one or more ASCII letters or digits and no punctuation or spaces.
Matches: Build2026
Does not match: Build-2026
Limitations: Unicode letters and underscores are intentionally excluded.
/\s+/gFinds one or more whitespace characters, including spaces, tabs, and line breaks.
Matches: hello world
Does not match: helloworld
Limitations: Whitespace semantics vary by engine and flags; this targets JavaScript behavior.
/ {2,}/gFinds two or more literal consecutive spaces for cleanup.
Matches: Too many spaces
Does not match: One space
Limitations: It does not match tabs or newlines; use \s{2,} when those should count.
/<\/?[A-Za-z][^>]*>/gFinds text shaped like an opening or closing HTML tag.
Matches: <section class="hero">
Does not match: 2 < 3
Limitations: Do not use regex as an HTML parser; nested structure, quoted > characters, and malformed markup need a parser.
/^[A-Za-z_$][A-Za-z0-9_$]*$/Checks the common ASCII shape of a JavaScript identifier.
Matches: user_$1
Does not match: 1stUser
Limitations: It does not reject reserved words and does not cover all Unicode identifier rules.
/"(?:\\.|[^"\\])*"/gFinds double-quoted strings while allowing escaped characters inside them.
Matches: "hello \"world\""
Does not match: 'hello'
Limitations: It is not a full language lexer and may not handle every multiline or templating syntax.
/\b(?:TRACE|DEBUG|INFO|WARN|ERROR|FATAL)\b/giFinds common severity labels in application logs.
Matches: 2026-10-11 INFO Request complete
Does not match: NOTICE Request complete
Limitations: Log formats and level names differ between systems.
/^\S+ \S+ \S+ \[[^\]]+\] "(?:[^"\\]|\\.)*" \d{3} \d+(?: "[^"]*" "[^"]*")?$/Matches the broad shape of a Common Log Format or combined access-log line.
Matches: 127.0.0.1 - - [11/Oct/2026:10:20:30 +0000] "GET / HTTP/1.1" 200 1234
Does not match: GET / returned okay
Limitations: It checks line shape, not whether methods, dates, status codes, or quoted fields are semantically valid.
/^v?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/Matches the core and optional prerelease/build portions of Semantic Versioning 2.0.
Matches: v1.4.0-beta.2
Does not match: 1.4
Limitations: It does not compare versions or enforce project-specific release rules.
/^(?:[0-9A-Fa-f]{2}[:-]){5}[0-9A-Fa-f]{2}$/Accepts six hexadecimal octets separated by colons or hyphens.
Matches: 00:1A:2B:3C:4D:5E
Does not match: 00:1A:2B:3C:4D
Limitations: It does not identify vendor prefixes or guarantee that the address is assigned to a device.
/^(?=.{1,253}$)(?:[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?\.)*[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?$/Checks labels, hyphen placement, and the maximum hostname length.
Matches: api.example.com
Does not match: -api.example.com
Limitations: It does not validate DNS resolution, IDN display names, or every application-specific host rule.
/^(?:\d|[1-9]\d{1,3}|[1-5]\d{4}|6[0-4]\d{3}|65[0-4]\d{2}|655[0-2]\d|6553[0-5])$/Matches an integer from 0 through 65535.
Matches: 443
Does not match: 70000
Limitations: It does not show whether a port is open or assigned to a particular service.
/^\/(?:[^\0\n\/]+\/)*[^\0\n\/]*$/Checks a slash-prefixed path without null bytes or newline characters.
Matches: /var/log/app.log
Does not match: var/log/app.log
Limitations: Filesystem rules differ by operating system, permissions, and normalization requirements.
/"(?:\\(?:["\\\/bfnrt]|u[0-9A-Fa-f]{4})|[^"\\\u0000-\u001F])*"/Matches a JSON string token with valid escape forms and no raw control characters.
Matches: "line\nvalue"
Does not match: "unescaped
line"
Limitations: A token match does not validate a complete JSON document; use a JSON parser for that.
/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/Checks the standard padded Base64 alphabet and grouping.
Matches: SGVsbG8=
Does not match: SGVsbG8!
Limitations: It does not decode the value or distinguish arbitrary binary data from text.
/^(?:0x)?[0-9A-Fa-f]+$/iAccepts hexadecimal digits with an optional 0x prefix.
Matches: 0xFF00AA
Does not match: 0xGHI
Limitations: It does not enforce a numeric width or range.
/^(?:\+1[ .-]?)?(?:\(?[2-9]\d{2}\)?[ .-]?)?[2-9]\d{2}[ .-]?\d{4}$/Accepts common North American phone formats with an optional country code.
Matches: +1 (415) 555-0132
Does not match: 123-45-6789
Limitations: Phone numbering plans are complex; this does not verify assignment or support every international format.
/^\d{5}(?:-\d{4})?$/Matches five-digit ZIP codes and optional four-digit extensions.
Matches: 94105-1234
Does not match: 9410
Limitations: It checks format only and does not confirm that the ZIP code exists.
/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/Matches an ISO-like date-time with seconds and an explicit UTC offset.
Matches: 2026-10-11T14:30:00Z
Does not match: 2026/10/11 14:30:00
Limitations: Calendar validity and leap seconds are not checked.
/^(?:\d+(?:\.\d+)?)(?:ms|s|m|h|d)$/iMatches a positive numeric duration with a common unit.
Matches: 2.5h
Does not match: two hours
Limitations: It does not convert units or accept compound durations such as 1h 30m.
/^"(?:""|[^"])*"$/Validates one quoted CSV field and permits doubled double-quotes inside it.
Matches: "two, too"
Does not match: "unterminated
Limitations: CSV dialects vary; this checks one quoted field only and does not parse a complete row.
$1) alters your text based on matched groups.g), case-insensitive (i), and multiline (m) matching.A Regular Expression (Regex) is a sequence of characters that specifies a search pattern. They are widely used for string parsing, input validation, data extraction, and search-and-replace workflows. This regex tester includes a searchable library of practical JavaScript regex patterns. For syntax details and edge cases, explore our Regex Cheat Sheet & Common Patterns.
To use this tester:
/, as they are handled automatically).g for global, i for case-insensitive).$1 and $2.Use the tester to build a pattern from a small set of representative inputs, then compare matches and replacement output before adding it to application code. For example, test both valid and invalid route IDs rather than checking only one successful sample.
Limit: A regex usually checks syntax or shape, not business meaning. Keep patterns bounded and review nested quantifiers because some expressions can cause excessive backtracking in a production engine.
A quick reference of common tokens, anchors, and quantifiers supported by the JavaScript RegExp engine.
In regex, a period . matches any character. To match a literal dot (such as in example.com), always escape it as example\.com.
When validating entire inputs (like emails or IDs), omitting ^ and $ allows unexpected substrings before or after the valid pattern to pass.
Expressions like <.*> will match from the first < to the last > in an entire file. Use lazy matching <.*?> instead.
Nested quantifiers like (a+)+$ cause exponential evaluation times on non-matching inputs. Keep quantifier nesting minimal and specific.
A complete developer reference guide with token syntax tables, quantifier rules, and pre-built patterns for email, URL, UUID, and more.
Regex is commonly used to parse and validate URLs. Use the URL Encoder to process query parameters and URI components.
Generate RFC 4122 Version 4 UUIDs to test identifier validation patterns in route parameters and databases.
Format and inspect structured JSON data before extracting or testing regex patterns on payload values.
Explore, reuse, and contribute tested JavaScript regex patterns in the public DevToolkit library.
This tool uses the native JavaScript RegExp engine running directly inside your browser. It reflects the exact behavior of regular expressions executed in Node.js, Next.js, and modern browser applications.
Without the global flag (g), a regular expression stops searching after identifying the very first match. Adding the 'g' flag tells the engine to find all matches throughout the entire input string.
Capture groups are defined with parentheses, like (\w+). In the Replace tab, you can reference these groups using $1 for the first group, $2 for the second group, and $& for the entire match.
By default, quantifiers like *, +, and {n,} are greedy — they match as much text as possible. Adding a question mark (like *? or +?) makes them lazy, matching only the shortest string necessary to satisfy the pattern.
Characters with special syntactic meaning in regex — such as . * + ? ^ $ { } ( ) [ ] | \ / — must be escaped with a preceding backslash (\) to match their literal character (e.g., \. to match a literal period).
No. DevToolkit runs 100% client-side in your browser. Your expressions, input text, and replacement results never leave your computer.