Find & Replace

How to Use the Find and Replace Tool

1. Paste your source text into the large input area. Any size up to several megabytes is handled without a round trip to a server.
2. Type what you want to find in the Find field. For literal text this is just the phrase; for pattern matching, enable Regex mode first.
3. Type the replacement in the Replace field. You can use $1, $2, $<name>, $&, and friends when Regex mode is on.
4. Toggle options depending on your intent: Case-sensitive turns matching into an exact-character comparison, Whole word adds word-boundary anchors, Regex mode interprets the Find field as a JavaScript regular expression.
5. Click Replace All. The result panel populates below along with a count of replacements performed.
6. Copy the result with the Copy button, or iterate by tweaking the Find or Replace fields and clicking Replace All again on the updated input.

What the Tool Does Under the Hood

In literal mode the Find string is escaped using a helper that prefixes every regex metacharacter (.\\+*?[](){}^$|) with a backslash, then compiled into a RegExp with the g flag - optionally i for case-insensitive - and passed to String.prototype.replaceAll (or replace with the global flag on older browsers). Whole-word mode wraps the escaped string in \\b...\\b anchors. Regex mode skips the escaping step entirely and compiles the Find field as-is, so you get full access to alternation, capture groups, lookarounds, and Unicode property escapes. The replacement string is processed by JavaScript's built-in replace semantics, which means $1 through $99 refer to numbered capture groups, $<name> refers to named groups, $& is the whole match, and $$ escapes a literal dollar sign. No text ever leaves the tab.

When You Would Use It

• Renaming a function or variable in a code snippet you pulled out of a larger file for review.
• Fixing a brand capitalization mistake across a blog post that quotes the name dozens of times.
• Converting Markdown to HTML-ish quickly: turn **bold** into <b>$1</b> with regex \\*\\*(.+?)\\*\\*.
• Reformatting CSV-like data by replacing commas with tabs or swapping column order via capture-group rearrangement.
• Redacting PII before sharing a log file: regex-replace /\\d{3}-\\d{2}-\\d{4}/g with XXX-XX-XXXX.
• Cleaning up translation files where every occurrence of a legacy product name needs to become the new one, but only when it appears as a whole word.

Common Pitfalls and Edge Cases

• Literal dollar signs. In replacement text, $ is special. To insert a literal $ use $$. Paste-and-pray replacement into code with price formatting often catches this.
• Unescaped regex metacharacters in literal mode. The tool escapes them for you, but if you switch to Regex mode mid-session without thinking, suddenly a parenthesis means capture group rather than literal paren.
• Greedy vs lazy quantifiers. <.+> against <a>...</a> captures the whole line because .+ is greedy; use <.+?> for the expected per-tag behavior.
• Whole word on non-Latin scripts. \\b is ASCII-centric - it finds boundaries between word characters ([A-Za-z0-9_]) and non-word characters. For CJK or Arabic text, word boundaries are not well defined and the option may behave surprisingly.
• Multi-line matches. The dot does not match newlines unless you enable dotAll via (?s) in newer engines or add the s flag in Regex mode. A pattern like foo.*bar will not match across line breaks without it.
• Catastrophic backtracking. Nested quantifiers such as (a+)+ applied to long non-matching input can freeze the tab. If Replace All hangs, your regex is the culprit.

Regex Replacement Background

JavaScript's replace method was standardized in ECMA-262 back in 1997 and has barely changed since. The replacement-string syntax - $n for groups, $& for match, $' and $` for suffix and prefix - traces back to Perl 4. sed uses \\1 through \\9 for the same purpose, which is why porting a regex between shell and JavaScript often requires adjusting backreferences. Named capture groups are a modern addition (ES2018) that make patterns self-documenting: (?<year>\\d{4})-(?<month>\\d{2})-(?<day>\\d{2}) replaced with $<day>/$<month>/$<year> reorders dates without ambiguity. PCRE supports \\g<name> and (?P=name) for similar effects; Python's re module uses \\g<name>.

Comparison to Alternatives

sed -E 's/foo/bar/g' file is the Unix workhorse for the same job - fast, scriptable, and POSIX-standard, though sed's regex dialect is subtly different from JavaScript's (no lookaheads in basic mode, different backreference syntax). perl -pe gives full Perl regex and inline editing and is what many bash scripts actually reach for when sed's ERE mode is not enough. Your IDE's Find-in-files is usually the right tool for cross-file replacement because it shows a preview and offers undo. ripgrep --replace and sd are fast Rust-based replacements for sed on modern systems. Use this web tool for a single-snippet, one-off change where you want instant visual feedback, capture-group playground semantics, and zero install - especially handy on a Chromebook, a phone, or a locked-down corporate machine.