1. Literals and Metacharacters: The Alphabet of Regex

Literal characters match the exact characters you type (e.g., dog matches “dog”). Metacharacters, however, have special meanings that unlock the power of pattern matching:

• . (Dot): Matches any single character except a newline.
• ^ (Caret): Matches the beginning of a string.
• $ (Dollar): Matches the end of a string.
• \d (Digit): Matches any digit (0-9).
• \s (Whitespace): Matches any whitespace character (space, tab, newline).
• \w (Word character): Matches any alphanumeric character (a-z, A-Z, 0-9) and the underscore (_).

Example: ^Hello will match “Hello world” but not “Say Hello”.

2. Quantifiers: Controlling Repetition

Quantifiers specify how many times a preceding character or group should appear in the match:

• * (Asterisk): Zero or more occurrences.
• + (Plus): One or more occurrences.
• ? (Question Mark): Zero or one occurrence.
• {n}: Exactly n occurrences.
• {n,}: n or more occurrences.
• {n,m}: Between n and m occurrences (inclusive).

Example: \d{3}-\d{2} matches “123-45” but not “12-345”. \d{2,4} matches “12”, “123”, and “1234”.

3. Character Classes: Defining Sets of Characters

Character classes define sets of characters to match.

• [abc]: Matches ‘a’, ‘b’, or ‘c’.
• [^abc]: Matches any character except ‘a’, ‘b’, or ‘c’.
• [a-z]: Matches any lowercase letter from ‘a’ to ‘z’.
• [A-Z]: Matches any uppercase letter from ‘A’ to ‘Z’.
• [0-9]: Matches any digit from 0 to 9 (equivalent to \d).

Example: [A-Za-z]+ matches one or more alphabetic characters (any word).

1. Grouping and Capturing: Extracting Specific Parts

Parentheses () are used to group parts of a regex and capture the matched text for later use. This is especially useful for extracting specific information from a string.

Example: (\d{3})-(\d{2}) applied to “123-45” will capture “123” in group 1 and “45” in group 2. Many programming languages allow you to access these captured groups individually.

2. Lookarounds: Asserting Context Without Matching

Lookarounds allow you to assert that a certain pattern exists before or after another pattern, without including the lookaround pattern in the actual match.

• (?=pattern) (Positive Lookahead): Asserts that the pattern follows.
• (?!pattern) (Negative Lookahead): Asserts that the pattern does not follow.
• (?<=pattern) (Positive Lookbehind): Asserts that the pattern precedes.
• (?<!pattern) (Negative Lookbehind): Asserts that the pattern does not precede.

Example: \d+(?= dollars) matches “100” in “100 dollars” but not in “100 euros”. (?<=\$)\d+ matches “25” in “$25” but not in “€25”.

3. Non-Greedy Matching: Minimizing Matches

By default, quantifiers are “greedy,” meaning they try to match as much text as possible. Adding a ? after a quantifier makes it “lazy” or “non-greedy,” causing it to match as little as possible.

Example: Given the string <div><p>Hello</p></div>, the regex <.*> would greedily match <div><p>Hello</p></div>. However, <.*?> would non-greedily match just <div>.

1. Email Validation: Ensuring Correct Format

A common, but not foolproof, regex for validating email addresses: ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$ Note: This is a simplified example and might not cover all valid email formats.

2. Extracting URLs: Finding Web Addresses

Match HTTP/HTTPS URLs: https?://[^\s]+

3. Log File Parsing: Identifying Key Information

Extract timestamps from log entries: \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}

4. Password Strength Validation

Enforce password policies using regex. For example, requiring at least one uppercase letter, one lowercase letter, one number, and a minimum length of 8 characters: ^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{8,}$