Regex Patterns Every Developer Should Know Practice Exam

Question 1 Regex Patterns Every Developer Should Know

What is the difference between `\A` and `^`?

\A matches only at the absolute start of the input and is not affected by the multiline flag. ^ matches the start of the input by default and at the start of every line with the m flag. Prefer \A when you want true "start of string" semantics. To match the same text that was previously captured. Common uses: finding doubled words with \b(\w+)\s+\1\b, or matching HTML tags with <(\w+)>.*?</\1>. ^yes$ with the i flag. Without the i flag, the pattern would only match lowercase yes. The anchors prevent partial matches in larger strings. In JavaScript: str.match(/-?\d+(\.\d+)?/g) with the g flag. In Python: re.findall(r'-?\d+(?:\.\d+)?', text). The pattern optionally allows a sign and decimal part.

Question 2 Regex Patterns Every Developer Should Know

What does the `(\d)\1` pattern match?

s.replace(/^0+(\d)/, '$1') in JavaScript, or re.sub(r'^0+(\d)', r'\1', s) in Python. The ^ anchors at the start, and the captured group preserves the first non-zero digit. Any two identical digits in a row, e.g. the 11 in a11b or the 00 in 100. \1 is a backreference to the first capturing group. Use (\d)\1{2,} to find 3+ identical digits in a row. A practical pattern is ^[A-Za-z_$][A-Za-z0-9_$]*$. It requires a letter, underscore, or dollar sign as the first character, followed by any number of word characters or dollar signs. ES2015 also allows Unicode letters, which require the u flag and \p{ID_Start} / \p{ID_Continue}. ^.{10}$ with the m flag. ^ and $ delimit the line, and . matches each of the 10 characters (newline excluded unless s flag).

Question 3 Regex Patterns Every Developer Should Know

How do you replace all whitespace runs with a single space?

^.{10}$ with the m flag. ^ and $ delimit the line, and . matches each of the 10 characters (newline excluded unless s flag). In JavaScript: str.replace(/\s+/g, ' '). In Python: re.sub(r'\s+', ' ', text). In sed: s/[[:space:]]\+/ /g. re.match anchors the pattern at the start of the string (equivalent to adding \A), returning a match only if the pattern matches the prefix. re.search scans the entire string and returns a match wherever the pattern first succeeds. Use ^ explicitly with re.search to anchor at the start. Makes the dot . also match newline characters. In JavaScript and PCRE this is s; in Python it is the inline (?s) or re.DOTALL.

Question 4 Regex Patterns Every Developer Should Know

What is the regex for a slug (lowercase letters, digits, and hyphens, not starting or ending with a hyphen)?

It asserts that the following text does NOT match the subpattern. For example, foo(?!bar) matches foo only when it is not followed by bar. ^[a-z0-9]+(?:-[a-z0-9]+)*$. It allows letters and digits, with optional hyphen-separated segments, and disallows leading, trailing, or consecutive hyphens. Use a hyphen between the endpoints, e.g. [a-z] matches lowercase ASCII letters and [0-9A-F] matches hexadecimal digits. The hyphen is literal at the start, end, or after \ inside the class. A group that can be referenced by name, written (?<name>...) in most flavors (or (?P<name>...) in Python). Access via \k<name> in the pattern and $name or group("name") in code.

Question 5 Regex Patterns Every Developer Should Know

How do you write a regex to match an integer in any base from 2 to 36?

Use a backreference. In most engines \1 refers to the first capturing group, e.g. ([abc])\1 matches aa, bb, or cc. In replacement strings use $1 (Perl/JavaScript) or \1 (sed). ^\d{1,3}(,\d{3})*$. It allows one to three digits, followed by zero or more groups of a comma and exactly three digits. It does not allow trailing commas, leading commas, or a comma after a non-three-digit group. There is no built-in way; you must enumerate: ^[01]+$|^[0-2]+$|... is impractical. A more practical approach uses ^(?:[0-1]+|...)$ per base, or you normalize the input and convert it numerically. Use the int(s, base) constructor in Python with a separate regex to validate the digit range. ^\s+$ with the m flag, or ^[ \t]+$ if you want to exclude blank lines that contain newlines.

Question 6 Regex Patterns Every Developer Should Know

What does the anchor `$` match?

The position at the end of the string. With the m flag it also matches before each newline. In JavaScript, without the m flag, $ still matches just before a final newline in some engines. A group written (?:...) that groups tokens for quantifiers or alternation but does not record the match. Use it to keep backreferences clean and slightly improve performance, e.g. (?:ab)+. ^[^,]* matches from the start to (but not including) the first comma, or none at all if there is no comma. In a multi-line context it only operates on the first line. [ \t]+$ with the m flag, or simply \s+$ if you also want to match trailing newlines as part of the same line. This is useful in linters that flag trailing whitespace.

Question 7 Regex Patterns Every Developer Should Know

What is backtracking in regex?

^\d+\.\d+\.\d+(?:-[\w.]+)?(?:\+[\w.-]+)?$. The first part matches three numeric components, the optional -... captures a pre-release identifier, and the optional +... captures build metadata, following semver 2.0.0. Changes the behavior of ^ and $ so they match at the start and end of every line within the input, not just the start and end of the whole string. It does NOT change how . behaves; that is the s flag. A common one is https?://[^\s/$.?#].[^\s]*. The first part enforces the scheme, the second part forbids whitespace and the URL delimiter characters, and the rest allows path/query/fragment characters. The process by which a regex engine, after failing to match later in the pattern, returns characters previously consumed by a greedy or lazy quantifier and tries again. Necessary for correct matching but can be exponential in time on adversarial inputs.

Question 8 Regex Patterns Every Developer Should Know

What does the negative lookahead `(?!...)` do?

A zero-width assertion between a word character (\w) and a non-word character (or the start/end of the string). It does not consume any characters, e.g. \bcat\b matches cat but not concatenate. It asserts that the following text does NOT match the subpattern. For example, foo(?!bar) matches foo only when it is not followed by bar. Changes the behavior of ^ and $ so they match at the start and end of every line within the input, not just the start and end of the whole string. It does NOT change how . behaves; that is the s flag. It matches as few characters as possible, expanding only as needed to satisfy the rest of the pattern. Useful for extracting content between the first and last delimiter, e.g. <.*?> matches a single tag.

Question 9 Regex Patterns Every Developer Should Know

How do you match any non-whitespace character?

\S, the negation of \s. \S+ matches one or more characters that are not space, tab, or newline. #(?:[0-9a-fA-F]{3}){1,2}\b. The \b at the end ensures the match stops at a word boundary so it does not gobble trailing characters like ; or ). \.([^.\\/]+)$. It captures one or more non-dot, non-slash characters at the end of the string after the last dot. Use it to extract extensions like tar from archive.tar. Written (?(condition)yes-pattern|no-pattern), it matches yes-pattern if the condition is true and optionally no-pattern otherwise. The condition can be a backreference number, e.g. (?(1)yes|no), which tests whether group 1 has been matched.

Question 10 Regex Patterns Every Developer Should Know

What is a regex to match a 24-hour time like `23:59`?

^([01]\d|2[0-3]):[0-5]\d$. Hours are constrained to 00-19 or 20-23, minutes are 00-59. Add :[0-5]\d for seconds. ^[aeiou][a-zA-Z]{4}$. Anchors fix the length, the first class picks a lowercase vowel (use i flag to allow uppercase), and the second class allows any letter for the remaining four positions. It precompiles a pattern string into a Pattern object that can be reused for multiple matches. It is more efficient when the same pattern is used many times, and it lets you set flags at compile time, e.g. re.compile(r'foo', re.IGNORECASE). It replaces occurrences of a pattern in a string with a replacement, returning a new string. The replacement can be a string with backreferences like \1, or a function that receives the match and returns the replacement text.

Question 11 Regex Patterns Every Developer Should Know

How do you specify a range of characters in a character class?

It is a common idiom meaning "start OR end of string". In a multi-line context it matches the boundary of any line. Sometimes written as a character class [\^$] to match a literal caret or dollar sign, which is a frequent source of bugs. Use a hyphen between the endpoints, e.g. [a-z] matches lowercase ASCII letters and [0-9A-F] matches hexadecimal digits. The hyphen is literal at the start, end, or after \ inside the class. A pathological case where a poorly written pattern causes the regex engine to try an exponential number of combinations before failing. Classic example: (a+)+$ on a string of many as followed by a non-a character. Atomic groups or possessive quantifiers can prevent it. * matches zero or more occurrences, so the pattern is optional and may match the empty string. + matches one or more, so at least one occurrence is required.

Question 12 Regex Patterns Every Developer Should Know

What does the `re.compile` function do in Python?

Escape it with a backslash: \.. Inside a character class the dot is literal even without escaping, but \. still works and is the safe habit. ^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$. It enforces 4-digit year, month 01-12, and day 01-31. Note that it does not validate months with fewer than 31 days or leap years. It precompiles a pattern string into a Pattern object that can be reused for multiple matches. It is more efficient when the same pattern is used many times, and it lets you set flags at compile time, e.g. re.compile(r'foo', re.IGNORECASE). ^\s+$ with the m flag, or ^[ \t]+$ if you want to exclude blank lines that contain newlines.

Question 13 Regex Patterns Every Developer Should Know

What is the difference between `^` outside and inside a character class?

A group written (?:...) that groups tokens for quantifiers or alternation but does not record the match. Use it to keep backreferences clean and slightly improve performance, e.g. (?:ab)+. A rough pattern is https?://([^/]+)/?. The capturing group holds the host portion, excluding the path. Edge cases include URLs with userinfo (user@host), ports, and IPv6 addresses in brackets; for those you need a more careful parser. Use inline flags. In JavaScript-style: (?i)foo(?-i)bar matches Foo and FOO but requires lowercase bar. In Python: (?i:foo)bar or re.I scoped with (?i:...). Outside a class, ^ is the start-of-string anchor. Inside [...], when it is the first character, it negates the class, so [^a-z] matches any character that is not a lowercase ASCII letter.

Question 14 Regex Patterns Every Developer Should Know

What does the shorthand `\s` match?

It asserts that the following text does NOT match the subpattern. For example, foo(?!bar) matches foo only when it is not followed by bar. ^[a-f0-9]{8}$. Anchors require the entire string, the class lists allowed characters, and the quantifier fixes the length. It makes the token optional (zero or one occurrence). For example, colou?r matches both color and colour. Any whitespace character: space, tab (\t), newline (\n), carriage return (\r), form feed (\f), and vertical tab (\v). In Unicode mode it can also match rare whitespace like the non-breaking space U+00A0.

Question 15 Regex Patterns Every Developer Should Know

How do you match an optional `s` at the end of a word like `https?`?

^yes$ with the i flag. Without the i flag, the pattern would only match lowercase yes. The anchors prevent partial matches in larger strings. Use a pattern like "(?:\\.|[^"\\])*". It greedily matches a double quote, then any number of either an escaped character (\.) or a non-quote, non-backslash character, then a closing quote. Append the ? quantifier to the literal: s?. The full pattern https? matches both http and https but not httpss. Makes the dot . also match newline characters. In JavaScript and PCRE this is s; in Python it is the inline (?s) or re.DOTALL.

Question 16 Regex Patterns Every Developer Should Know

What is catastrophic backtracking?

A pathological case where a poorly written pattern causes the regex engine to try an exponential number of combinations before failing. Classic example: (a+)+$ on a string of many as followed by a non-a character. Atomic groups or possessive quantifiers can prevent it. \S, the negation of \s. \S+ matches one or more characters that are not space, tab, or newline. ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$. It enforces the 8-4-4-4-12 grouping, the 4 in the version position, and the 8/9/a/b bits in the variant nibble, matching the v4 specification. Matches a doubled word where the second occurrence has the same spelling as the first. (?<word>...) is a named capturing group, and \k<word> is a backreference to it, equivalent to \1 but with a name.

Question 17 Regex Patterns Every Developer Should Know

What does the shorthand `\w` match?

^.{10}$ with the m flag. ^ and $ delimit the line, and . matches each of the 10 characters (newline excluded unless s flag). $(\d{3})$\s*(\d{3})-(\d{4}). The parentheses must be escaped because ( and ) are metacharacters. The three groups capture area code, prefix, and line number. A DFA (deterministic finite automaton) never backtracks, runs in linear time, and cannot support backreferences or lookaround. An NFA (non-deterministic) engine, used by PCRE, Python re, JavaScript, and most modern libraries, supports all those features but may backtrack. Any word character. In ASCII mode this is [A-Za-z0-9_]; in Unicode mode it also matches letters and digits from other scripts, and the underscore.

Question 18 Regex Patterns Every Developer Should Know

What is the equivalent of `re.match` in JavaScript?

^#([0-9A-Fa-f]{3}){1,2}$. It allows either 3-digit shorthand or 6-digit notation. With the i flag you can drop the A-F uppercase letters and write [0-9a-f]. ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$. It enforces the 8-4-4-4-12 grouping, the 4 in the version position, and the 8/9/a/b bits in the variant nibble, matching the v4 specification. A group that can be referenced by name, written (?<name>...) in most flavors (or (?P<name>...) in Python). Access via \k<name> in the pattern and $name or group("name") in code. JavaScript's String.prototype.match without the g flag behaves like a search, finding the first match anywhere. To anchor at the start, prefix the pattern with ^. There is no separate match method that anchors by default.

Question 19 Regex Patterns Every Developer Should Know

What is the meaning of the lazy quantifier `.*?`?

A positive-lookbehind that asserts the position is preceded by $, then one or more digits optionally followed by a dot and exactly two digits. It matches a price like 19.99 in $19.99 without including the dollar sign in the match. A group that can be referenced by name, written (?<name>...) in most flavors (or (?P<name>...) in Python). Access via \k<name> in the pattern and $name or group("name") in code. It matches as few characters as possible, expanding only as needed to satisfy the rest of the pattern. Useful for extracting content between the first and last delimiter, e.g. <.*?> matches a single tag. A single character of any kind except the newline character (\n). To make it also match newlines, use the s (dotall / single-line) flag, e.g. /foo.bar/s in JavaScript or re.DOTALL in Python.

Question 20 Regex Patterns Every Developer Should Know

Which regex engine does JavaScript use?

A pathological case where a poorly written pattern causes the regex engine to try an exponential number of combinations before failing. Classic example: (a+)+$ on a string of many as followed by a non-a character. Atomic groups or possessive quantifiers can prevent it. ^[a-z0-9]+(?:-[a-z0-9]+)*$. It allows letters and digits, with optional hyphen-separated segments, and disallows leading, trailing, or consecutive hyphens. ^[a-f0-9]{8}$. Anchors require the entire string, the class lists allowed characters, and the quantifier fixes the length. The V8 and SpiderMonkey engines implement ECMAScript regex, which is an NFA-based engine. Modern engines (V8 irregexp) compile patterns to specialized bytecode and have added optimizations, but semantics are still NFA-based.

Question 21 Regex Patterns Every Developer Should Know

How do you extract the year, month, and day from a date string like `2025-03-15`?

(\d{4})-(\d{2})-(\d{2}). The three capturing groups return the year, month, and day as separate strings. In JavaScript, use match or exec; in Python, re.search(...).groups() returns the tuple. ^[aeiou][a-zA-Z]{4}$. Anchors fix the length, the first class picks a lowercase vowel (use i flag to allow uppercase), and the second class allows any letter for the remaining four positions. A common one is https?://[^\s/$.?#].[^\s]*. The first part enforces the scheme, the second part forbids whitespace and the URL delimiter characters, and the rest allows path/query/fragment characters. $(\d{3})$\s*(\d{3})-(\d{4}). The parentheses must be escaped because ( and ) are metacharacters. The three groups capture area code, prefix, and line number.

Question 22 Regex Patterns Every Developer Should Know

How do you match a hexadecimal color code like `#1A2B3C`?

^#([0-9A-Fa-f]{3}){1,2}$. It allows either 3-digit shorthand or 6-digit notation. With the i flag you can drop the A-F uppercase letters and write [0-9a-f]. An empty non-capturing group. It has no effect on matching, but in some flavors it is used to apply flags to a subexpression, e.g. (?i:abc) turns on case-insensitivity for abc only. It lets you add whitespace and # comments inside the pattern for readability, e.g. (?x)^\d{3} # area code - \d{4}$ # line number. Whitespace in the pattern is ignored unless escaped or inside a character class. It matches at the end of the string, or just before a final newline. In PCRE and Python it is similar to $ with the multiline flag, except \Z is not affected by the m flag, while $ is anchored at end-of-string in single-line mode.

Question 23 Regex Patterns Every Developer Should Know

How do you match a quoted string with possibly escaped quotes inside?

^#([0-9A-Fa-f]{3}){1,2}$. It allows either 3-digit shorthand or 6-digit notation. With the i flag you can drop the A-F uppercase letters and write [0-9a-f]. Use a pattern like "(?:\\.|[^"\\])*". It greedily matches a double quote, then any number of either an escaped character (\.) or a non-quote, non-backslash character, then a closing quote. JavaScript's String.prototype.match without the g flag behaves like a search, finding the first match anywhere. To anchor at the start, prefix the pattern with ^. There is no separate match method that anchors by default. ^#(?:[0-9a-fA-F]{3}){1,2}(?:[0-9a-fA-F]{2})?$. The optional 8-digit form is the 6-digit color plus a 2-digit alpha channel. This pattern is greedy in the right places: 3+3 = 6, and the optional pair of hex digits appends for 8.

Question 24 Regex Patterns Every Developer Should Know

How do you capture the value of a key like `name="alice"` in HTML attributes?

It asserts that the following text does NOT match the subpattern. For example, foo(?!bar) matches foo only when it is not followed by bar. name\s*=\s*"([^"]*)". The captured group holds the value. Use ['"] for either quote type, or [^'"]* to allow mixed quotes. To enforce multiple independent rules in a single regex without consuming characters. For example, ^(?=.*[A-Z])(?=.*\d).{8,}$ requires at least one uppercase and one digit anywhere in an 8+ character string, while the final .{8,}$ does the actual matching. ^.{10}$ with the m flag. ^ and $ delimit the line, and . matches each of the 10 characters (newline excluded unless s flag).

Question 25 Regex Patterns Every Developer Should Know

How do you match any character that is NOT a word character?

A common practical pattern is

^(25[0-5]|2[0-4]\d|[01]?\d\d?)\.(25[0-5]|2[0-4]\d|[01]?\d\d?)\.(25[0-5]|2[0-4]\d|[01]?\d\d?)\.(25[0-5]|2[0-4]\d|[01]?\d\d?)$

. Each octet must be 0-255 and is written out to forbid leading zeros in some variants. str.replace(regex, (match, ...captures, offset, fullString) => replacement). The first argument is the full match, followed by the captured groups, then the offset and the original string. Use it for dynamic replacements like reordering date components. \W, equivalent to [^A-Za-z0-9_] in ASCII mode. Useful for stripping punctuation, e.g. replace \W+ with a single space. Tells the regex to find all matches in the string instead of stopping at the first. Methods like String.prototype.matchAll and String.prototype.replace with a regex need it to iterate every match.

Question 26 Regex Patterns Every Developer Should Know

How do you match the body of an HTML `<script>` tag?

A simple pattern is <script\b[^>]*>([\s\S]*?)</script>. The lazy quantifier and the [\s\S] trick (any char including newline) avoid greedy matching of nested or multiple script blocks. ^/[A-Za-z0-9._~!$&'()+,;=:@/-]*$. This is a simplified RFC 3986 path character class with the unreserved set plus the sub-delims and a few others commonly seen. For strict validation you should percent-decode and re-validate segments. \b(\w+)\s+\1\b with case-insensitive flag if needed. The capturing group (\w+) matches a word and the backreference \1 requires the next word to be identical. ^\d{4}([ -]?)\d{4}\1\d{4}\1\d{4}$. The backreference \1 ensures that whatever separator is used (space, dash, or none) is consistent across all four groups. This is a shape check, not a Luhn-check; always run a checksum before accepting.

Question 27 Regex Patterns Every Developer Should Know

How do you reference a captured group inside the same pattern?

^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$. It enforces the 8-4-4-4-12 grouping, the 4 in the version position, and the 8/9/a/b bits in the variant nibble, matching the v4 specification. It asserts that the following text does NOT match the subpattern. For example, foo(?!bar) matches foo only when it is not followed by bar. \Z matches at the end of the string, or before a final newline. \z matches strictly at the very end of the string, with no exception for a trailing newline. Use \z when you need to reject a trailing newline. Use a backreference. In most engines \1 refers to the first capturing group, e.g. ([abc])\1 matches aa, bb, or cc. In replacement strings use $1 (Perl/JavaScript) or \1 (sed).

Question 28 Regex Patterns Every Developer Should Know

How do you match an empty line?

Outside a class, ^ is the start-of-string anchor. Inside [...], when it is the first character, it negates the class, so [^a-z] matches any character that is not a lowercase ASCII letter. A zero-width assertion between a word character (\w) and a non-word character (or the start/end of the string). It does not consume any characters, e.g. \bcat\b matches cat but not concatenate. A rough pattern is https?://([^/]+)/?. The capturing group holds the host portion, excluding the path. Edge cases include URLs with userinfo (user@host), ports, and IPv6 addresses in brackets; for those you need a more careful parser. ^\s*$ with the m flag. The ^ and $ delimit an empty line, and \s* allows it to be filled with whitespace (so a line of only spaces also matches).

Question 29 Regex Patterns Every Developer Should Know

What is a regex pattern that matches a URL starting with `http` or `https`?

A common one is https?://[^\s/$.?#].[^\s]*. The first part enforces the scheme, the second part forbids whitespace and the URL delimiter characters, and the rest allows path/query/fragment characters. Use a built-in helper. JavaScript has no standard one; a common one-liner is str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'). Python: re.escape(str). Java: Pattern.quote(str). Never embed raw user input as a regex without escaping. ^[A-Za-z0-9]+$. The anchors ensure the entire string is consumed, and the character class restricts the content. Add a length check separately if you need an exact length. Use a backreference. In most engines \1 refers to the first capturing group, e.g. ([abc])\1 matches aa, bb, or cc. In replacement strings use $1 (Perl/JavaScript) or \1 (sed).

Question 30 Regex Patterns Every Developer Should Know

What is the regex to strip HTML tags from a string?

Greedy quantifiers backtrack to find a match. Possessive quantifiers (written with a trailing +, e.g. .*+ in PCRE/Java) never backtrack, so they can fail faster and prevent catastrophic backtracking. Python 3.11 added possessive quantifiers in the regex module and Python 3.11+ in the re module via inline flags. A group written (?:...) that groups tokens for quantifiers or alternation but does not record the match. Use it to keep backreferences clean and slightly improve performance, e.g. (?:ab)+. \D, equivalent to [^0-9] in ASCII mode, or [^\d] using a negated class. \D+ matches one or more non-digit characters. A basic version is <[^>]+>, replace with empty string. It does not handle malformed HTML, CDATA sections, or comments, so prefer a real sanitizer like DOMPurify for security-sensitive contexts.

Question 31 Regex Patterns Every Developer Should Know

What does the `re.sub` function in Python do?

A parenthesized subexpression that records the matched text so it can be referenced later. By default groups are numbered left-to-right starting at 1, e.g. (\d{4})-(\d{2}) captures year and month separately. It replaces occurrences of a pattern in a string with a replacement, returning a new string. The replacement can be a string with backreferences like \1, or a function that receives the match and returns the replacement text. ^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$. The alternation handles 3- or 6-digit forms. Anchors prevent partial matches, and case-insensitivity is achieved by including both ranges in the class. In JavaScript: str.replace(/\s+/g, ' '). In Python: re.sub(r'\s+', ' ', text). In sed: s/[[:space:]]\+/ /g.

Question 32 Regex Patterns Every Developer Should Know

How do you write a regex that matches a string with an even number of `x` characters?

^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$. It enforces 4-digit year, month 01-12, and day 01-31. Note that it does not validate months with fewer than 31 days or leap years. It replaces occurrences of a pattern in a string with a replacement, returning a new string. The replacement can be a string with backreferences like \1, or a function that receives the match and returns the replacement text. ^(?:[^x]*x[^x]*x)*[^x]*$. It repeatedly matches pairs of x surrounded by non-x characters, with optional non-x filler at the ends. This is hard to express with simple quantifiers and shows the power of group iteration. ^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$. The alternation handles 3- or 6-digit forms. Anchors prevent partial matches, and case-insensitivity is achieved by including both ranges in the class.

Question 33 Regex Patterns Every Developer Should Know

What is a common regex to match a date in the form YYYY-MM-DD?

^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$. It enforces 4-digit year, month 01-12, and day 01-31. Note that it does not validate months with fewer than 31 days or leap years. [0-9] or the shorthand \d. \d is equivalent to [0-9] in ASCII; with Unicode (u flag in JS, default in Python 3 str) it matches any Unicode decimal digit, e.g. Arabic-Indic digits. Escape it with a backslash: \.. Inside a character class the dot is literal even without escaping, but \. still works and is the safe habit. A group written (?:...) that groups tokens for quantifiers or alternation but does not record the match. Use it to keep backreferences clean and slightly improve performance, e.g. (?:ab)+.

Question 34 Regex Patterns Every Developer Should Know

How do you match a credit-card-shaped 16-digit number with optional separators?

^[^,]* matches from the start to (but not including) the first comma, or none at all if there is no comma. In a multi-line context it only operates on the first line. ^\d{4}([ -]?)\d{4}\1\d{4}\1\d{4}$. The backreference \1 ensures that whatever separator is used (space, dash, or none) is consistent across all four groups. This is a shape check, not a Luhn-check; always run a checksum before accepting. An empty non-capturing group. It has no effect on matching, but in some flavors it is used to apply flags to a subexpression, e.g. (?i:abc) turns on case-insensitivity for abc only. It precompiles a pattern string into a Pattern object that can be reused for multiple matches. It is more efficient when the same pattern is used many times, and it lets you set flags at compile time, e.g. re.compile(r'foo', re.IGNORECASE).

Question 35 Regex Patterns Every Developer Should Know

What does the regex metacharacter `.` match by default?

The process by which a regex engine, after failing to match later in the pattern, returns characters previously consumed by a greedy or lazy quantifier and tries again. Necessary for correct matching but can be exponential in time on adversarial inputs. A single character of any kind except the newline character (\n). To make it also match newlines, use the s (dotall / single-line) flag, e.g. /foo.bar/s in JavaScript or re.DOTALL in Python. \Z matches at the end of the string, or before a final newline. \z matches strictly at the very end of the string, with no exception for a trailing newline. Use \z when you need to reject a trailing newline. str.replace(regex, (match, ...captures, offset, fullString) => replacement). The first argument is the full match, followed by the captured groups, then the offset and the original string. Use it for dynamic replacements like reordering date components.

Question 36 Regex Patterns Every Developer Should Know

How do you escape all regex metacharacters in a user-supplied string?

s.replace(/^0+(\d)/, '$1') in JavaScript, or re.sub(r'^0+(\d)', r'\1', s) in Python. The ^ anchors at the start, and the captured group preserves the first non-zero digit. .*\d.* or, in a stricter check, \d is enough because any match anywhere in the string counts. To require at least one digit, use ^(?=.*\d).*$ with a lookahead if you plan to add other rules. Use a built-in helper. JavaScript has no standard one; a common one-liner is str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'). Python: re.escape(str). Java: Pattern.quote(str). Never embed raw user input as a regex without escaping. Use inline flags. In JavaScript-style: (?i)foo(?-i)bar matches Foo and FOO but requires lowercase bar. In Python: (?i:foo)bar or re.I scoped with (?i:...).

Question 37 Regex Patterns Every Developer Should Know

How do you match a digit, a hyphen, and three more digits?

\d-\d{3}. The hyphen is literal because it is not in a character class. Written (?(condition)yes-pattern|no-pattern), it matches yes-pattern if the condition is true and optionally no-pattern otherwise. The condition can be a backreference number, e.g. (?(1)yes|no), which tests whether group 1 has been matched. One or more consecutive ASCII letters. The + requires at least one, and the character class excludes digits, underscores, and accented letters. Any whitespace character: space, tab (\t), newline (\n), carriage return (\r), form feed (\f), and vertical tab (\v). In Unicode mode it can also match rare whitespace like the non-breaking space U+00A0.

Question 38 Regex Patterns Every Developer Should Know

Which character class matches any single digit in most regex flavors?

[0-9] or the shorthand \d. \d is equivalent to [0-9] in ASCII; with Unicode (u flag in JS, default in Python 3 str) it matches any Unicode decimal digit, e.g. Arabic-Indic digits. A group that can be referenced by name, written (?<name>...) in most flavors (or (?P<name>...) in Python). Access via \k<name> in the pattern and $name or group("name") in code. ^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$. The alternation handles 3- or 6-digit forms. Anchors prevent partial matches, and case-insensitivity is achieved by including both ranges in the class. The V8 and SpiderMonkey engines implement ECMAScript regex, which is an NFA-based engine. Modern engines (V8 irregexp) compile patterns to specialized bytecode and have added optimizations, but semantics are still NFA-based.

Question 39 Regex Patterns Every Developer Should Know

What is a lookahead used for in password validation?

In JavaScript: str.match(/-?\d+(\.\d+)?/g) with the g flag. In Python: re.findall(r'-?\d+(?:\.\d+)?', text). The pattern optionally allows a sign and decimal part. To enforce multiple independent rules in a single regex without consuming characters. For example, ^(?=.*[A-Z])(?=.*\d).{8,}$ requires at least one uppercase and one digit anywhere in an 8+ character string, while the final .{8,}$ does the actual matching. \S, the negation of \s. \S+ matches one or more characters that are not space, tab, or newline. A common practical pattern is

^(25[0-5]|2[0-4]\d|[01]?\d\d?)\.(25[0-5]|2[0-4]\d|[01]?\d\d?)\.(25[0-5]|2[0-4]\d|[01]?\d\d?)\.(25[0-5]|2[0-4]\d|[01]?\d\d?)$

. Each octet must be 0-255 and is written out to forbid leading zeros in some variants.

Question 40 Regex Patterns Every Developer Should Know

What is the regex to find a hex color in CSS source code?

Any whitespace character: space, tab (\t), newline (\n), carriage return (\r), form feed (\f), and vertical tab (\v). In Unicode mode it can also match rare whitespace like the non-breaking space U+00A0. A group written (?:...) that groups tokens for quantifiers or alternation but does not record the match. Use it to keep backreferences clean and slightly improve performance, e.g. (?:ab)+. #(?:[0-9a-fA-F]{3}){1,2}\b. The \b at the end ensures the match stops at a word boundary so it does not gobble trailing characters like ; or ). Changes the behavior of ^ and $ so they match at the start and end of every line within the input, not just the start and end of the whole string. It does NOT change how . behaves; that is the s flag.

Question 41 Regex Patterns Every Developer Should Know

What does the `re.X` (or `x`) verbose flag allow?

It lets you add whitespace and # comments inside the pattern for readability, e.g. (?x)^\d{3} # area code - \d{4}$ # line number. Whitespace in the pattern is ignored unless escaped or inside a character class. ^.{10}$ with the m flag. ^ and $ delimit the line, and . matches each of the 10 characters (newline excluded unless s flag). (\d{4})-(\d{2})-(\d{2}). The three capturing groups return the year, month, and day as separate strings. In JavaScript, use match or exec; in Python, re.search(...).groups() returns the tuple. Matches a doubled word where the second occurrence has the same spelling as the first. (?<word>...) is a named capturing group, and \k<word> is a backreference to it, equivalent to \1 but with a name.

Question 42 Regex Patterns Every Developer Should Know

How do you match the file extension of a filename?

\.([^.\\/]+)$. It captures one or more non-dot, non-slash characters at the end of the string after the last dot. Use it to extract extensions like tar from archive.tar. ^\d+\.\d+\.\d+(?:-[\w.]+)?(?:\+[\w.-]+)?$. The first part matches three numeric components, the optional -... captures a pre-release identifier, and the optional +... captures build metadata, following semver 2.0.0. Outside a class, ^ is the start-of-string anchor. Inside [...], when it is the first character, it negates the class, so [^a-z] matches any character that is not a lowercase ASCII letter. It asserts that the following text matches the subpattern without consuming it. For example, \d+(?=px) matches the digits in 42px but not in 42em.

Question 43 Regex Patterns Every Developer Should Know

What is the regex pattern that matches any whitespace at the end of a line?

A group written (?>...) (in PCRE/Java/Python 3.11+ re) that, once it has matched, never releases characters even if the rest of the pattern forces backtracking. It is an alternative to possessive quantifiers and helps prevent exponential backtracking. str.replace(regex, (match, ...captures, offset, fullString) => replacement). The first argument is the full match, followed by the captured groups, then the offset and the original string. Use it for dynamic replacements like reordering date components. Changes the behavior of ^ and $ so they match at the start and end of every line within the input, not just the start and end of the whole string. It does NOT change how . behaves; that is the s flag. [ \t]+$ with the m flag, or simply \s+$ if you also want to match trailing newlines as part of the same line. This is useful in linters that flag trailing whitespace.

Question 44 Regex Patterns Every Developer Should Know

How do you match a CSS hex color including the 3-, 6-, and 8-digit forms?

A rough pattern is https?://([^/]+)/?. The capturing group holds the host portion, excluding the path. Edge cases include URLs with userinfo (user@host), ports, and IPv6 addresses in brackets; for those you need a more careful parser. ^#(?:[0-9a-fA-F]{3}){1,2}(?:[0-9a-fA-F]{2})?$. The optional 8-digit form is the 6-digit color plus a 2-digit alpha channel. This pattern is greedy in the right places: 3+3 = 6, and the optional pair of hex digits appends for 8. Use a backreference. In most engines \1 refers to the first capturing group, e.g. ([abc])\1 matches aa, bb, or cc. In replacement strings use $1 (Perl/JavaScript) or \1 (sed). It is a zero-width assertion that checks what precedes the current position. Positive: (?<=...), negative: (?<!...). JavaScript supports lookbehinds since ES2018, and Python/PCRE support them with a fixed width in older versions and variable width in PCRE2 and Python 3.11+.

Question 45 Regex Patterns Every Developer Should Know

What is a backreference used for?

A rough pattern is https?://([^/]+)/?. The capturing group holds the host portion, excluding the path. Edge cases include URLs with userinfo (user@host), ports, and IPv6 addresses in brackets; for those you need a more careful parser. \b(\w+)\s+\1\b with case-insensitive flag if needed. The capturing group (\w+) matches a word and the backreference \1 requires the next word to be identical. \D, equivalent to [^0-9] in ASCII mode, or [^\d] using a negated class. \D+ matches one or more non-digit characters. To match the same text that was previously captured. Common uses: finding doubled words with \b(\w+)\s+\1\b, or matching HTML tags with <(\w+)>.*?</\1>.

Question 46 Regex Patterns Every Developer Should Know

What is the regex pattern for a valid IPv4 address?

re.match anchors the pattern at the start of the string (equivalent to adding \A), returning a match only if the pattern matches the prefix. re.search scans the entire string and returns a match wherever the pattern first succeeds. Use ^ explicitly with re.search to anchor at the start. A common practical pattern is

^(25[0-5]|2[0-4]\d|[01]?\d\d?)\.(25[0-5]|2[0-4]\d|[01]?\d\d?)\.(25[0-5]|2[0-4]\d|[01]?\d\d?)\.(25[0-5]|2[0-4]\d|[01]?\d\d?)$

. Each octet must be 0-255 and is written out to forbid leading zeros in some variants. It asserts that the following text does NOT match the subpattern. For example, foo(?!bar) matches foo only when it is not followed by bar. POSIX defines named classes enclosed in [: and :] inside a bracket expression, e.g. [[:alpha:]]+ matches one or more letters. Other examples are [:digit:], [:space:], [:alnum:], [:upper:], [:lower:], [:punct:], [:xdigit:].

Question 47 Regex Patterns Every Developer Should Know

What does the pattern `^.*$` actually do?

A DFA (deterministic finite automaton) never backtracks, runs in linear time, and cannot support backreferences or lookaround. An NFA (non-deterministic) engine, used by PCRE, Python re, JavaScript, and most modern libraries, supports all those features but may backtrack. Any two identical digits in a row, e.g. the 11 in a11b or the 00 in 100. \1 is a backreference to the first capturing group. Use (\d)\1{2,} to find 3+ identical digits in a row. It matches a whole line in multiline mode, or the entire string otherwise. The dot-star is redundant when you are already anchoring at both ends, so ^.*$ is effectively a more expensive version of just ^$ for empty-line checks. A group written (?>...) (in PCRE/Java/Python 3.11+ re) that, once it has matched, never releases characters even if the rest of the pattern forces backtracking. It is an alternative to possessive quantifiers and helps prevent exponential backtracking.

Question 48 Regex Patterns Every Developer Should Know

How do you capture the area code from a US phone number like `(555) 123-4567`?

$(\d{3})$\s*(\d{3})-(\d{4}). The parentheses must be escaped because ( and ) are metacharacters. The three groups capture area code, prefix, and line number. It asserts that the following text does NOT match the subpattern. For example, foo(?!bar) matches foo only when it is not followed by bar. ^(?:[^x]*x[^x]*x)*[^x]*$. It repeatedly matches pairs of x surrounded by non-x characters, with optional non-x filler at the ends. This is hard to express with simple quantifiers and shows the power of group iteration. ^.*\bTODO\b.*$ with the m flag, or simply use a regex test like /\bTODO\b/.test(line). \b ensures you do not match TODOS or MYTODO.

Question 49 Regex Patterns Every Developer Should Know

How do you match everything up to the first occurrence of a comma?

^[^,]* matches from the start to (but not including) the first comma, or none at all if there is no comma. In a multi-line context it only operates on the first line. It matches at the end of the string, or just before a final newline. In PCRE and Python it is similar to $ with the multiline flag, except \Z is not affected by the m flag, while $ is anchored at end-of-string in single-line mode. [aeiou]. Add i flag for case-insensitivity, or write [aeiouAEIOU]. Negate with [^aeiou] to match any non-vowel. \S, the negation of \s. \S+ matches one or more characters that are not space, tab, or newline.

Question 50 Regex Patterns Every Developer Should Know

How do you match a string of length 5 starting with a vowel?

JavaScript's String.prototype.match without the g flag behaves like a search, finding the first match anywhere. To anchor at the start, prefix the pattern with ^. There is no separate match method that anchors by default. ^[aeiou][a-zA-Z]{4}$. Anchors fix the length, the first class picks a lowercase vowel (use i flag to allow uppercase), and the second class allows any letter for the remaining four positions. Use inline flags. In JavaScript-style: (?i)foo(?-i)bar matches Foo and FOO but requires lowercase bar. In Python: (?i:foo)bar or re.I scoped with (?i:...). A rough pattern is https?://([^/]+)/?. The capturing group holds the host portion, excluding the path. Edge cases include URLs with userinfo (user@host), ports, and IPv6 addresses in brackets; for those you need a more careful parser.

What is the difference between \A and ^?

What does the (\d)\1 pattern match?