The Regex 20: Text Wrangling Drills in R

Explanation: In a regex, . matches any single character, so the pattern .csv would also match strings like xcsv. Writing \\. escapes the metacharacter to a literal period. The double backslash is needed because R first parses the string, turning \\. into \., which the regex engine then reads as an escaped dot. archive.CSV stays FALSE because matching is case sensitive by default; pass ignore.case = TRUE if you want uppercase extensions too.

Explanation: grep() and grepl() share a pattern engine but return different things: grepl() returns a logical vector, grep() returns integer positions, and grep(..., value = TRUE) returns the matched elements. The character class [0-9] matches a single digit anywhere in the string, so any code with at least one number survives. A common mistake is reaching for grepl() and then subsetting with it; grep(value = TRUE) does both steps in one call.

Explanation: POSIX classes like [[:space:]], [[:alpha:]] and [[:digit:]] are portable, readable names for common character sets. [[:space:]] matches spaces, tabs and newlines, which is safer than a literal " " when data may contain tab separators. Note the double brackets: the inner [:space:] is the class name and the outer [...] makes it a character set, so a single-bracket [:space:] would wrongly match the literal characters :, s, p and so on.

Explanation: The caret ^ anchors a pattern to the start of the string, so ^sales_ only matches when those characters are the very first ones. q1_sales.csv contains sales_ but not at the start, so it fails. Anchors match a position, not a character, which is why they never consume anything. The mirror anchor is $ for the end of the string; combine both as ^...$ to force a whole-string match.

Explanation: The + quantifier means "one or more of the preceding item", so [0-9]+ matches a run of digits of any length. Anchoring with $ forces that run to sit at the end of the string, which is why admin fails and guest9 passes. Without $ the pattern would match a digit anywhere, flagging strings like v2beta. Related quantifiers are * (zero or more) and ? (zero or one); reach for + when at least one occurrence is required.

Explanation: The bounded quantifier {3,5} means "at least three, at most five" repetitions. Anchoring with ^ and $ is what makes this a validation rather than a search: it forces the entire field to consist of nothing but three to five digits, so 123456 (six digits) and 1 (one digit) both fail. Drop the anchors and the pattern would match any three-to-five digit run inside a longer string, which is a frequent validation bug.

Explanation: str_extract() returns the first substring that matches, keeping the result the same length as the input so it lines up with the original vector. When a string has no match it yields NA rather than dropping the element, which is exactly why the third entry is NA. This length-preserving behaviour is the key difference from base regmatches(), which silently drops non-matching elements and breaks positional alignment. Use str_extract_all() when you need every match, not just the first.

Explanation: In base R, extraction is a two-step dance: gregexpr() returns the positions and lengths of every match, and regmatches() uses those to slice out the actual substrings. The g prefix means "global", so it finds all matches rather than just the first the way regexpr() does. Because the input could be a vector, regmatches() returns a list with one element per string; index with [[1]] to get the character vector. The stringr one-liner str_extract_all() does the same job with less ceremony.

Explanation: The pattern [A-Z][a-z]+ reads as "one uppercase letter followed by at least one lowercase letter", a compact heuristic for a capitalized word. str_extract_all() returns a list because each string can have a different number of matches, so a rectangular result is impossible. This is a heuristic, not a grammar: it would also grab a sentence's first word even when it is not a proper noun, and it misses all-caps acronyms. For real named-entity work you would move to a dedicated NLP tool.

Explanation: gsub() replaces every match of the pattern; the g again stands for "global". Matching the class [0-9] one character at a time and swapping in # masks each digit while leaving the hyphens, which are not digits, in place. Reach for sub() instead when only the first occurrence should change. A common slip is trying to mask with a fixed-width pattern like [0-9]{16}; matching a single digit repeatedly is simpler and survives odd groupings.

Explanation: sub() and gsub() differ in a single but important way: sub() replaces only the first match in each string, gsub() replaces them all. Because a year-month-day string has two hyphens, sub("-", "/", ...) converts just the first, giving 2024/01-15. If you had reached for gsub() here you would get 2024/01/15, changing both separators. When a transformation should touch only the leading occurrence, sub() is the precise tool.

Explanation: Parentheses in a pattern create capture groups, numbered left to right by their opening bracket. In the replacement string, \\1 and \\2 are backreferences that insert whatever those groups matched, so "\\2, \\1" writes the last name, a comma, then the first. The anchors ^ and $ plus \\w+ for each name keep the match tight to a simple two-word full name. This pattern would need extending for middle names or hyphenated surnames, but it is the canonical shape for reordering fields.

Explanation: str_match() returns a character matrix where the first column is the entire match and each subsequent column is one capture group, in order. That layout makes it ideal for tearing a structured string into fields in a single call. Contrast it with str_extract(), which returns only the whole match and no group columns. When a string does not match, the whole row comes back as NA, preserving the one-row-per-input alignment so you can bind it beside the source data.

Explanation: The s? makes the s optional so the pattern matches both http and https, and [^/]+ is a negated character class meaning "one or more characters that are not a slash", which stops the host capture at the first path separator. str_match() returns the full match in column 1 and the host group in column 2, so [, 2] keeps only what you want. Negated classes like [^/] are the workhorse for "everything up to the next delimiter" without resorting to greedy wildcards.

Explanation: A lookahead (?=...) asserts that the text ahead matches without consuming it, so [0-9]+(?=ms) matches a run of digits only when ms follows, yet returns just the digits. The 3s case yields NA because its unit is not ms. stringr uses the ICU regex engine, which supports lookarounds natively, so no extra flag is needed here. In base R you would enable the same feature with perl = TRUE. Lookarounds shine when a neighbour must exist but should stay out of the captured text.

Explanation: By default quantifiers are greedy: .+ grabs as much as it can, so <.+> would match from the first < all the way to the final > in one go. Adding ? after the quantifier makes it lazy, matching as few characters as possible, so <.+?> stops at the first > and each tag is captured on its own. The [[1]] unwraps the single-element list str_extract_all() returns. Regex is famously the wrong tool for parsing real HTML, but for tokenizing simple tags the lazy trick is exactly right.

Explanation: The Perl-compatible engine, enabled with perl = TRUE, adds case-modifier escapes usable in the replacement string: \\U forces following text to uppercase and \\L to lowercase, until reset. The pattern (\\w)(\\w*) captures a word's first character and its remaining characters as two groups, and the replacement \\U\\1\\L\\2 uppercases the first and lowercases the rest. gsub() applies this to every word in the string. These modifiers are a Perl feature, so they silently do nothing without perl = TRUE, which is the classic gotcha.

Explanation: The caret inside a character class, as in [^0-9], negates it, so the class matches any character that is not a digit. Replacing all such characters with "" in gsub() deletes the parentheses, dots, spaces and dashes in one pass, leaving only the digits. This "keep the good characters" approach scales far better than enumerating every separator to remove. For international numbers you would afterward inspect length and country prefix, since stripping punctuation alone does not validate that a number has the right digit count.

Explanation: The pattern anchors the whole string and breaks the address into parts: [[:alnum:]._%+-]+ for the local name, a literal @, [[:alnum:].-]+ for the domain labels, then \\.[[:alpha:]]{2,}$ demanding a dot followed by a top-level part of at least two letters. bad@ and no-at-sign fail on structure, and x@y.z fails because its final part is a single letter. No regex fully validates email against the formal spec, so this is a pragmatic filter that catches the common malformed cases without rejecting real addresses.

Explanation: This is the end-to-end payoff: one pattern with five groups turns each log line into structured fields. ([0-9.]+) grabs the dotted IP, .* skips the two dash placeholders, "(\\w+) ([^"]+)" captures the method and the quoted path, and the two trailing ([0-9]+) groups take the status and byte count. str_match() returns a matrix whose columns 2 through 6 are the groups, and data.frame() binds them into a table, with as.integer() restoring numeric types that regex always returns as text. For heavy log volumes a purpose-built parser is faster, but this shows how capture groups reshape raw text into analysis-ready rows.