Regex Basics for Beginners

A regular expression is a pattern that describes text. Most characters are literals — the pattern cat matches the letters c, a, t in order. The power comes from metacharacters, which have special meaning. The dot . matches any single character; \d matches any digit; \w matches a word character (letters, digits, underscore); \s matches whitespace. So \d\d:\d\d matches a time like 09:45, and c.t matches cat, cot, or cut.

Because metacharacters are special, matching one literally means escaping it with a backslash: to match an actual dot (like in a file name) you write \. — the pattern file\.txt matches 'file.txt' but not 'fileXtxt'. Forgetting to escape is the most common beginner bug, since . silently matches far more than intended.

Character classes in square brackets match any one of a set: [aeiou] matches a single vowel, [a-z] any lowercase letter, [0-9] any digit, and a leading caret negates it — [^0-9] matches any non-digit. Quantifiers say how many times: * is zero or more, + is one or more, ? is zero or one, and {2,4} is between two and four. So [a-z]+ matches a run of lowercase letters and \d{3}-\d{4} matches 555-1234.

Anchors pin a pattern to a position rather than matching characters. ^ means start of the string (or line), $ means end. ^\d+$ means 'the entire string is nothing but digits' — useful for validation, because without anchors \d+ would happily match the '5' inside 'abc5def'. The word boundary \b matches the edge between a word and a non-word character, so \bcat\b matches 'cat' but not 'category'.

Parentheses create groups, which let a quantifier apply to a whole chunk and let you capture part of a match for reuse. (ab)+ matches 'ababab'; in a find-and-replace, capture groups become $1, $2 so you can reorder or extract pieces. The pipe | means 'or' inside a group: (cat|dog) matches either word. Groups are where regex stops being validation and becomes a text-transformation tool.

The classic gotcha is greedy matching. By default * and + grab as much as possible, so the pattern <.+> against '<a> <b>' matches the entire '<a> <b>' rather than just '<a>' — because .+ swallows everything up to the last >. Add a ? to make a quantifier lazy (.+?) and it takes as little as possible, matching '<a>' then '<b>' separately. Greedy-by-default surprises nearly everyone once, and the lazy ? is the fix.