Find and Replace

Swapping one string for another across a wall of text — renaming a variable in a snippet, updating a product name through a draft, normalising a column of scraped data — is the job find and replace exists for. What usually goes wrong is not the swap itself but not being able to see what it is about to touch. This tool highlights every match in the text as you type the search term, so the count and the damage are visible before you copy anything out.

Plain-text mode matches exactly what you type and inserts your replacement exactly as typed, dollar signs and backslashes included. Regex mode gives you the rest: character classes, quantifiers, capture groups you can reorder with $1 and $2, named groups, and the flags that actually matter in a replace tool. Line anchors are on by default, so a pattern beginning with ^ applies to every line rather than only the first — the single most common thing people want from regex here and the thing most simple tools get wrong.

Two options cut down on collateral damage. Whole words only stops a short search term rewriting the insides of longer words, and it works in plain-text mode, so you do not have to learn word-boundary syntax to get the safe behaviour. Preserve the original case gives each replacement the casing of the text it replaced: searching case-insensitively for "cat" turns CAT into DOG, Cat into Dog and cat into dog in one pass, instead of flattening all three.

Bigger jobs need more than one rule. Add as many as you need and they run top to bottom, each over the output of the one before it, with its own replacement count next to it — which also makes the ordering trap visible, since a later rule can match text an earlier one produced. You can step through a single occurrence at a time, feed the result back into the input for another pass, undo anything, restrict the work to lines containing a particular string, and load or save the text as a file. It all runs in your browser.

In plain-text mode your search term is escaped for you, so a dot matches a dot and a bracket matches a bracket. Less obviously, the replacement is inserted verbatim too. That matters because a dollar sign has a special meaning in JavaScript replacements — $& means the matched text, $$ means one dollar — and a tool that hands your replacement straight to the language will quietly mangle a price, a shell variable or a LaTeX fragment. Here plain text means plain text in both fields.

Switch to regular expressions and those references come back deliberately: $1 and $2 for capture groups, $<name> for a named one, $& for the whole match. That is how a reformat happens in one pass — capturing the parts of a date and writing them back in a different order rather than replacing anything at all.

Because both fields are single-line, escape sequences fill the gap. Typing \n in either field means a real line break, and \t a tab, which is what makes "put each comma-separated item on its own line" a single replacement rather than an impossibility. Switch that reading off if you genuinely need a backslash followed by an n.

Substring matching is the usual cause of damage. Replacing a short word without word boundaries also rewrites it inside longer words, so replacing "art" quietly changes "start", "particle" and "chart". Ticking Whole words only is the fix, and unlike the regex-only advice most tools offer, it works while you stay in plain-text mode. The highlighted matches make the problem obvious anyway: if four things light up when you expected one, the search term is wrong.

Order matters once you have more than one rule. If a later rule can match what an earlier one produced, the two interact and the result depends on sequence — replacing A with B and then B with C turns the original A into C, which is rarely what anyone wanted. The rules list numbers each step and shows its own count, so an unexpected number tells you where the collision is. Using a placeholder unlikely to occur naturally as an intermediate step avoids it entirely.

Two smaller traps. A pattern that can match nothing — x* or \s* on its own — matches the empty string between every character, so the replacement is inserted throughout rather than over anything; the tool says so when it happens. And a pattern that applies a quantifier to an already-quantified group, like (a+)+, can take exponentially long on a long line. That gets flagged before it runs, because once a regular expression starts there is no way to interrupt it.