Find and replace with regular expressions.

Download Caxton for Free · 7-day free trial of Caxton Pro, no credit card required · 7 MB · macOS 13.0+

Which regular expression engine does Caxton use?

Caxton runs ICU regular expressions through the system's NSRegularExpression, the same engine behind most Mac and iOS apps. Three facts about it shape everything below. Patterns are evaluated one line at a time, so a match never crosses a line ending, ^ and $ mean the start and end of each line, and . never matches a line break. In the replacement, $0 is the whole match and $1 through $9 are the capture groups, with \1 reserved for backreferences inside the pattern itself. And lookahead and lookbehind, positive and negative, are part of the grammar.

In the find bar, .* turns regular expressions on, Aa sets whether case matters, and the \n toggle expands escape sequences such as \n and \t in a literal search, which is how a search crosses a line break. Edit ▸ Find ▸ Find and Replace… has the same options as a Search mode popup: Normal, Extended for the escape sequences, or Regular expression. Finding, counting and highlighting are free; Replace and Replace All change the file, so they are Caxton Pro.

The Terminal equivalents below use Apple's own grep and sed with -E, the extended syntax. Two cautions apply on a Mac. The stock sed needs -i '', with the empty quotes, to edit a file in place, and Apple's grep and sed know neither lookahead nor lookbehind nor the lazy ? suffix, so those rows carry a plain-syntax alternative instead.

How do I match the beginning or the end of a line?

Because Caxton evaluates each line on its own, there is no multiline option to remember: the anchors always refer to the line, and a pattern that ends in $ never swallows the line break. A replacement at ^ or $ inserts text at that edge of every line, which is the whole trick behind adding a prefix or a suffix.

How do I match whitespace and trailing spaces?

How do quantifiers work, and what does lazy mean?

Quantifiers are greedy: <.+> on <a><b> matches the whole thing, from the first < to the last >. Appending ? makes it lazy, so <.+?> matches <a> and then <b>. Caxton accepts the lazy form. Apple's sed -E rejects it with "repetition-operator operand invalid," and grep -E is not documented to honor it, so in the Terminal write what you mean with a negated class instead: <[^>]+> matches a tag because it cannot run past the closing bracket. That form is also faster in every engine.

What are character classes?

How do capture groups work in the replacement?

Parentheses capture what they match, numbered from the left, and the replacement can reuse them. In Caxton write $1, $2 and so on, with $0 for the whole match. In sed -E write \1 and \2. A group you only need for grouping, not for reuse, is written (?:…) and gets no number.

Inside the pattern itself a backreference is written \1 in both engines: (\w+) \1 finds a word repeated twice in a row, such as "the the". Caxton's Find All results panel can also group matches by the $1 value, which turns a capture into a quick frequency count without replacing anything.

What are lookahead and lookbehind?

A lookaround checks what comes next or before without including it in the match, so the replacement touches only the part you captured. Caxton supports all four forms. Apple's grep and sed do not, and their -E syntax has no equivalent; for a Terminal route, capture the context and put it back with a group, which the last row shows.

How do I match or insert a line break?

Two different jobs, with two different answers. To insert a line break, put \n in the replacement: Caxton expands it in Regular expression mode and in Extended mode, so replacing , with ,\n splits a comma-separated line into one item per line. In sed, the replacement needs a backslash followed by an actual line break, written across two lines:

sed -E 's/, /,\
/g' list.txt

To match a line break, remember that Caxton evaluates regular expressions one line at a time, so a pattern cannot reach across the break. Switch regular expressions off, turn the \n toggle on, and search for the literal text with the break written as \n: first\nsecond finds "first" at the end of one line followed by "second" at the start of the next, and a replacement of first second joins them. Pasting a selection that spans lines into the bar writes it in that form for you. The Text menu has a faster route for the common cases: Join Lines, Remove Empty Lines, and Split Lines at Delimiter…, each one undo step.

In the Terminal, sed reads one line at a time too, and joining lines is simpler with tr or paste: paste -sd ' ' file.txt joins every line with a space, and tr -d '\n' < file.txt removes the breaks outright.

How do I make a pattern case-insensitive?

In Caxton, leave the Aa toggle off and the pattern ignores case; turn it on to match exactly. ICU also accepts the inline flag (?i) at the start of a pattern. In the Terminal, grep -Ei ignores case, and Apple's sed takes an I flag after the closing delimiter: sed -E 's/error/ERROR/I'.

Recipes

Each recipe was run on a Mac with Apple's grep and sed and in Caxton's find bar with .* on. The sed forms print to the screen; add -i '' after sed to change the file in place, and keep a copy first. In Caxton, Replace All applies the whole recipe as one undo step, so ⌘Z brings the file back.

Remove trailing spaces

Find:     \s+$
Replace:  (nothing)

sed -E 's/[[:space:]]+$//' file.txt

Every line keeps its line break and loses the spaces and tabs before it. Caxton's Text ▸ Whitespace menu has Trim Trailing Whitespace for the same job without a pattern.

Delete blank lines

sed -E '/^$/d' file.txt
grep -Ev '^$' file.txt

A find and replace cannot do this one in Caxton, because the match would have to include the line break and a regular expression stays within its line. Use Text ▸ Lines ▸ Remove Empty Lines, which deletes blank lines in one step and counts a line of spaces or tabs as blank, or Text ▸ Delete Lines Matching… with ^\s*$ and Regular expression on, which previews the count first.

Wrap every line in quotes

Find:     ^(.*)$
Replace:  "$1"

sed -E 's/^(.*)$/"\1"/' file.txt

Add a prefix or a suffix to every line

Find:     ^          Replace:  >
Find:     $          Replace:  ;

sed -E 's/^/> /' file.txt
sed -E 's/$/;/' file.txt

Both anchors are zero-width, so the replacement is inserted and nothing is removed. Caxton applies a $ replacement once per line, including the last line of a file that has no final line break.

Swap two comma-separated fields

Find:     ^([^,]*),([^,]*)$
Replace:  $2,$1

sed -E 's/^([^,]*),([^,]*)$/\2,\1/' file.txt

[^,]* means "anything but a comma," which is what keeps each group inside its own field. For a file with more columns, or with quoted fields that contain commas, open it as a table instead: Caxton's grid moves whole columns, and transforming a CSV column covers the rest.

Delete every line that contains a word

sed -E '/DEBUG/d' file.txt
grep -Ev 'DEBUG' file.txt

In Caxton, Text ▸ Delete Lines Matching… takes the pattern, shows a preview with the count and a few sample lines, and deletes them as one undo step. Deleting is Caxton Pro. To only look at the file without those lines, Filter Lines (⇧⌘L) hides them as a view and is free.

Keep only lines that match

grep -E 'ERROR' file.txt
sed -En '/ERROR/p' file.txt

Filter Lines is the free way to see only the matching lines in Caxton, with the match count in the status bar and the rest of the file one click away. Delete Lines Matching… with Keep only matching lines ticked makes it permanent, and Extract sends the matching lines to a new document; both change or create a file, so both are Caxton Pro.

When the file is large

None of this changes with size. Caxton counts every match in a 10 GB file exactly, highlights the first 2 million of them, and runs Replace All as one bulk edit with a single undo. A pattern that would run away stops after ten seconds per 100 MB scanned and says so in the bar instead of hanging. Find and replace in a huge file has the numbers, and find and replace across many files covers a folder at a time.

Frequently asked questions

Sources

• Caxton manual: Find and Replace, with the search reference
• Caxton manual: Editing, the Text menu and Delete Lines Matching
• ICU User Guide: Regular Expressions
• Apple Developer Documentation: NSRegularExpression
• Apple's manual pages on macOS: man grep, man sed, man re_format, man paste and man tr, read with the shipped tools in Terminal