What does .+? mean in regex?

. matches any character, + means one or more, and ? makes it lazy so it matches as few characters as possible instead of as many as possible.

What is the difference between * and + in regex?

* matches zero or more occurrences of the preceding element, while + matches one or more. For example, a* matches an empty string but a+ requires at least one 'a'.

How do I match a literal dot in regex?

Escape it with a backslash: \.. An unescaped dot matches any character except newline.

What is a capture group in regex?

Parentheses () create a capture group that extracts part of a match. You can reference captured text with \1 or $1 in replacements. Use (?:...) for non-capturing groups.

Regex Tester | Kopdog Dev Tools

Pattern

Common Patterns

/ / g

Test String

Matches 0 matches

Enter a pattern and test string

Capture Groups

No capture groups

About Regular Expressions

Regular expressions (regex) are patterns used to match character combinations in text. They are supported in virtually every programming language and are essential for search, validation, and text processing tasks.

Syntax Quick Reference

Pattern	Description	Example
`.`	Any character except newline	`a.c` matches "abc", "a1c"
`\d`	Any digit (0-9)	`\d{3}` matches "123"
`\w`	Word character (letter, digit, underscore)	`\w+` matches "hello_1"
`\s`	Whitespace (space, tab, newline)	`\s+` matches spaces between words
`^`	Start of string (or line in multiline mode)	`^Hello` matches "Hello world"
`$`	End of string (or line in multiline mode)	`world$` matches "Hello world"
`*`	Zero or more of previous	`ab*c` matches "ac", "abc", "abbc"
`+`	One or more of previous	`ab+c` matches "abc", "abbc" but not "ac"
`?`	Zero or one of previous (optional)	`colou?r` matches "color" and "colour"
`{n,m}`	Between n and m of previous	`\d{2,4}` matches 2 to 4 digits
`[abc]`	Any character in the set	`[aeiou]` matches any vowel
`()`	Capture group	`(\d+)-(\d+)` captures two numbers
`\|`	Alternation (OR)	`cat\|dog` matches "cat" or "dog"
`\b`	Word boundary	`\bword\b` matches whole word only

Character Classes

[abc] matches any single character in the set. [^abc] matches any character not in the set. [a-z] matches a range. Shorthand classes like \d (digits), \w (word characters), and \s (whitespace) cover common patterns. Their uppercase versions (\D, \W, \S) match the opposite.

Quantifiers

By default, quantifiers are greedy - they match as much as possible. Adding ? makes them lazy (match as little as possible). {n} matches exactly n times, {n,} matches n or more, and {n,m} matches between n and m times.

Groups and Lookarounds

Capturing group (pattern) - extracts matched text, referenced as \1, $1
Non-capturing group (?:pattern) - groups without capturing
Named group (?<name>pattern) - captures with a name
Positive lookahead (?=pattern) - asserts what follows without consuming
Negative lookahead (?!pattern) - asserts what does not follow
Positive lookbehind (?<=pattern) - asserts what precedes
Negative lookbehind (?<!pattern) - asserts what does not precede