The principal search command in Emacs is incremental: it begins searching as soon as you type the first character of the search string. As you type in the search string, Emacs shows you where the string (as you have typed it so far) would be found. When you have typed enough characters to identify the place you want, you can stop. Depending on what you plan to do next, you may or may not need to terminate the search explicitly with RET.

C-s

Incremental search forward (isearch-forward).

C-r

Incremental search backward (isearch-backward).

You can also invoke incremental search from the menu bar's Edit->Search menu.

Emacs also has conventional nonincremental search commands, which require you to type the entire search string before searching begins.

C-s RET string RET

Search for string.

C-r RET string RET

Search backward for string.

To start a nonincremental search, first type C-s RET. This enters the minibuffer to read the search string; terminate the string with RET, and then the search takes place. If the string is not found, the search command signals an error. When you type C-s RET, the C-s invokes incremental search as usual. That command is specially programmed to invoke the command for nonincremental search, if the string you specify is empty. (Such an empty argument would otherwise be useless.) C-r =RET= does likewise, invoking the nonincremental backward-searching command. Nonincremental search can also be invoked from the menu bar's Edit->Search menu. You can also use two simpler commands, M-x search-forward and M-x search-backward. These commands look for the literal strings you specify, and don't support any of the lax-search features (Lax Search) except case folding.

A word search finds a sequence of words without regard to the type of punctuation between them. For instance, if you enter a search string that consists of two words separated by a single space, the search matches any sequence of those two words separated by one or more spaces, newlines, or other punctuation characters. This is particularly useful for searching text documents, because you don't have to worry whether the words you are looking for are separated by newlines or spaces. Note that major modes for programming languages or other specialized modes can modify the definition of a word to suit their syntactic needs.

M-s w

If incremental search is active, toggle word search mode (isearch-toggle-word); otherwise, begin an incremental forward word search (isearch-forward-word).

M-s w RET words RET

Search for words, using a forward nonincremental word search.

M-s w C-r RET words RET

Search backward for words, using a nonincremental word search.

M-s M-w

Search the Web for the text in region.

To begin a forward incremental word search, type M-s w. If incremental search is not already active, this runs the command isearch-forward-word. If incremental search is already active (whether a forward or backward search), M-s w runs the command isearch-toggle-word, which switches to a word search while keeping the direction of the search and the current search string unchanged. You can toggle word search back off by typing M-s w again. To begin a nonincremental word search, type M-s w RET for a forward search, or M-s w C-r RET for a backward search. These run the commands word-search-forward and word-search-backward respectively. Incremental and nonincremental word searches differ slightly in the way they find a match. In a nonincremental word search, each word in the search string must exactly match a whole word. In an incremental word search, the matching is more lax: while you are typing the search string, its first and last words need not match whole words. This is so that the matching can proceed incrementally as you type. This additional laxity does not apply to the lazy highlight (Incremental Search), which always matches whole words. While you are typing the search string, Pending appears in the search prompt until you use a search repeating key like C-s. The word search commands don't perform character folding, and toggling lax whitespace matching (lax space matching) has no effect on them. To search the Web for the text in region, type M-s M-w. This command performs an Internet search for the words in region using the search engine whose URL is specified by the variable eww-search-prefix (EWW). If the region is not active, or doesn't contain any words, this command prompts the user for a URL or keywords to search. You can also search for definitions of a word by querying dictionary servers via the @sc{dict} protocol defined by RFC 2229. Emacs includes a client for this protocol. Type M-x dictionary-search =RET= to connect to a @sc{dict} server and ask it to provide the available definitions of a word. This command prompts for the word to look up, using the word at point as the default, then asks the @sc{dict} server to provide the definitions of that word in one or more dictionaries. By default, the command first tries to connect to the @sc{dict} server installed on the local host, and if that fails, it tries dict.org after asking for confirmation; customize the variable dictionary-server to specify, as a string, the URL of a single server to use (use localhost if you want to query only the local server). Normally, dictionary-search tells the server to look up the word in all the dictionaries available to the server, but if you invoke the command with a prefix argument, it will prompt for a single dictionary to use. The list of dictionaries available to a server can be displayed by pressing the Select dictionary button shown in the *Dictionary* buffer, described below. The first time you use dictionary-search, it creates a new *Dictionary* buffer and turns on a special mode in it. The buffer shows buttons for selecting a dictionary, searching a definition of another word, etc. Subsequent dictionary-search commands reuse this buffer. To create another such buffer (e.g., to look up other words, perhaps in another dictionary), type M-x dictionary =RET=. If you turn on dictionary-tooltip-mode in a buffer, Emacs will look up the definitions of the word at mouse pointer and show those definitions in a tool tip. This is handy when you are reading text with many words about whose meaning you are unsure. For other options of dictionary-search, see the dictionary customization group (Specific Customization).

A symbol search is much like an ordinary search, except that the boundaries of the search must match the boundaries of a symbol. The meaning of symbol in this context depends on the major mode, and usually refers to a source code token, such as a Lisp symbol in Emacs Lisp mode. For instance, if you perform an incremental symbol search for the Lisp symbol forward-word, it would not match isearch-forward-word. This feature is thus mainly useful for searching source code.

M-s _

If incremental search is active, toggle symbol search mode (isearch-toggle-symbol); otherwise, begin an incremental forward symbol search (isearch-forward-symbol).

M-s .

Start a symbol incremental search forward with the symbol found near point added to the search string initially.

M-s _ RET symbol RET

Search forward for symbol, nonincrementally.

M-s _ C-r RET symbol RET

Search backward for symbol, nonincrementally.

To begin a forward incremental symbol search, type M-s _ (or M-s . if the symbol to search is near point). If incremental search is not already active, M-s _ runs the command isearch-forward-symbol and M-s . runs the command isearch-forward-symbol-at-point. With a numeric prefix argument of n, M-s . will search for the n/the next occurrence of the symbol at point; negative values of /n search backwards. If incremental search is already active, M-s _ switches to a symbol search, preserving the direction of the search and the current search string; you can disable symbol search by typing M-s _ again. In incremental symbol search, while you are typing the search string, only the beginning of the search string is required to match the beginning of a symbol, and Pending appears in the search prompt until you use a search repeating key like C-s. To begin a nonincremental symbol search, type M-s _ RET for a forward search, or M-s _ C-r RET or a backward search. In nonincremental symbol searches, the beginning and end of the search string are required to match the beginning and end of a symbol, respectively. The symbol search commands don't perform character folding, and toggling lax whitespace matching (lax space matching) has no effect on them.

A regular expression (or regexp for short) is a pattern that denotes a class of alternative strings to match. Emacs provides both incremental and nonincremental ways to search for a match for a regexp. The syntax of regular expressions is explained in the next section.

C-M-s

Begin incremental regexp search (isearch-forward-regexp).

C-M-r

Begin reverse incremental regexp search (isearch-backward-regexp).

Incremental search for a regexp is done by typing C-M-s (isearch-forward-regexp), by invoking C-s with a prefix argument (whose value does not matter), or by typing M-r within a forward incremental search. This command reads a search string incrementally just like C-s, but it treats the search string as a regexp rather than looking for an exact match against the text in the buffer. Each time you add text to the search string, you make the regexp longer, and the new regexp is searched for. To search backward for a regexp, use C-M-r (isearch-backward-regexp), C-r with a prefix argument, or M-r within a backward incremental search. All of the special key sequences in an ordinary incremental search (Special Isearch) do similar things in an incremental regexp search. For instance, typing C-s immediately after starting the search retrieves the last incremental search regexp used and searches forward for it. Incremental regexp and non-regexp searches have independent defaults. They also have separate search rings, which you can access with M-p and M-n. The maximum number of search regexps saved in the search ring is determined by the value of regexp-search-ring-max, 16 by default. Unlike ordinary incremental search, incremental regexp search does not use lax space matching by default. To toggle this feature use M-s SPC (isearch-toggle-lax-whitespace). Then any SPC typed in incremental regexp search will match any sequence of one or more whitespace characters. The variable search-whitespace-regexp specifies the regexp for the lax space matching. Special Isearch. Also unlike ordinary incremental search, incremental regexp search cannot use character folding (Lax Search). (If you toggle character folding during incremental regexp search with M-s ', the search becomes a non-regexp search and the search pattern you typed is interpreted as a literal string.) In some cases, adding characters to the regexp in an incremental regexp search can make the cursor move back and start again. For example, if you have searched for foo and you add \|bar, the cursor backs up in case the first bar precedes the first foo. (The prompt will change to say "Pending" to notify the user that this recalculation has happened.) Regexps. Forward and backward regexp search are not symmetrical, because regexp matching in Emacs always operates forward, starting with the beginning of the regexp. Thus, forward regexp search scans forward, trying a forward match at each possible starting position. Backward regexp search scans backward, trying a forward match at each possible starting position. These search methods are not mirror images. Nonincremental search for a regexp is done with the commands re-search-forward and re-search-backward. You can invoke these with M-x, or by way of incremental regexp search with C-M-s RET and C-M-r RET. When you invoke these commands with M-x, they search for the exact regexp you specify, and thus don't support any lax-search features (Lax Search) except case folding. If you use the incremental regexp search commands with a prefix argument, they perform ordinary string search, like isearch-forward and isearch-backward. Incremental Search.

This section (and this manual in general) describes regular expression features that users typically use. Regular Expressions, for additional features used mainly in Lisp programs. Regular expressions have a syntax in which a few characters are special constructs and the rest are ordinary. An ordinary character matches that same character and nothing else. The special characters are $^.*+?[\. The character ] is special if it ends a bracket expression (see below). The character - is special inside a bracket expression. Any other character appearing in a regular expression is ordinary, unless a \ precedes it. (When you use regular expressions in a Lisp program, each \ must be doubled, see the example near the end of this section.) For example, f is not a special character, so it is ordinary, and therefore f is a regular expression that matches the string f and no other string. (It does not match the string ff.) Likewise, o is a regular expression that matches only o. (When case distinctions are being ignored, these regexps also match F and O, but we consider this a generalization of "the same string", rather than an exception.) Any two regular expressions a and b can be concatenated. The result is a regular expression which matches a string if a matches some amount of the beginning of that string and b matches the rest of the string. As a trivial example, concatenating the regular expressions f and o gives the regular expression fo, which matches only the string fo. To do something less trivial, you need to use one of the special characters. Here is a list of them.

. (Period)

is a special character that matches any single character except a newline. For example, the regular expressions a.b matches any three-character string that begins with a and ends with b.

*

is not a construct by itself; it is a postfix operator that means to match the preceding regular expression repetitively any number of times, as many times as possible. Thus, o* matches any number of o=s, including no =o=s. =* always applies to the smallest possible preceding expression. Thus, fo* has a repeating o, not a repeating fo. It matches f, fo, foo, and so on. The matcher processes a * construct by matching, immediately, as many repetitions as can be found. Then it continues with the rest of the pattern. If that fails, backtracking occurs, discarding some of the matches of the *-modified construct in case that makes it possible to match the rest of the pattern. For example, in matching ca*ar against the string caaar, the a* first tries to match all three a=s; but the rest of the pattern is =ar and there is only r left to match, so this try fails. The next alternative is for a* to match only two =a=s. With this choice, the rest of the regexp matches successfully.

+

is a postfix operator, similar to * except that it must match the preceding expression at least once. Thus, ca+r matches the strings car and caaaar but not the string cr, whereas ca*r matches all three strings.

?

is a postfix operator, similar to * except that it can match the preceding expression either once or not at all. Thus, ca?r matches car or cr, and nothing else.

*?, +?, ??

are non-greedy variants of the operators above. The normal operators *, +, ? match as much as they can, as long as the overall regexp can still match. With a following ?, they will match as little as possible. Thus, both ab* and ab*? can match the string a and the string abbbb; but if you try to match them both against the text abbb, ab* will match it all (the longest valid match), while ab*? will match just a (the shortest valid match). Non-greedy operators match the shortest possible string starting at a given starting point; in a forward search, though, the earliest possible starting point for match is always the one chosen. Thus, if you search for a.*?$ against the text abbab followed by a newline, it matches the whole string. Since it can match starting at the first a, it does.

[ ... ]

is a bracket expression (a.k.a. set of alternative characters), which matches one of a set of characters. In the simplest case, the characters between the two brackets are what this set can match. Thus, [ad] matches either one a or one d, and [ad]* matches any string composed of just a=s and =d=s (including the empty string). It follows that =c[ad]*r matches cr, car, cdr, caddaar, etc. You can also include character ranges in a character set, by writing the starting and ending characters with a - between them. Thus, [a-z] matches any lower-case ASCII letter. Ranges may be intermixed freely with individual characters, as in [a-z$%.], which matches any lower-case ASCII letter or $, % or period. As another example, [α-ωί] matches all lower-case Greek letters. You can also include certain special character classes in a character set. A [: and balancing :] enclose a character class inside a bracket expression. For instance, [[:alnum:]] matches any letter or digit. Char Classes, for a list of character classes. To include a ] in a character set, you must make it the first character. For example, []a] matches ] or a. To include a -, write - as the last character of the set, tho you can also put it first or after a range. Thus, []-] matches both ] and -. To include ^ in a set, put it anywhere but at the beginning of the set. (At the beginning, it complements the set—see below.) When you use a range in case-insensitive search, you should write both ends of the range in upper case, or both in lower case, or both should be non-letters. The behavior of a mixed-case range such as A-z is somewhat ill-defined, and it may change in future Emacs versions.

[^ ... ]

[^ begins a complemented character set, which matches any character except the ones specified. Thus, [^a-z0-9A-Z] matches all characters except ASCII letters and digits. ^ is not special in a character set unless it is the first character. The character following the ^ is treated as if it were first (in other words, - and ] are not special there). A complemented character set can match a newline, unless newline is mentioned as one of the characters not to match. This is in contrast to the handling of regexps in programs such as grep.

^

is a special character that matches the empty string, but only at the beginning of a line in the text being matched. Otherwise it fails to match anything. Thus, ^foo matches a foo that occurs at the beginning of a line. For historical compatibility reasons, ^ can be used with this meaning only at the beginning of the regular expression, or after \( or \|.

$

is similar to ^ but matches only at the end of a line. Thus, x+$ matches a string of one x or more at the end of a line. For historical compatibility reasons, $ can be used with this meaning only at the end of the regular expression, or before \) or \|.

\

has two functions: it quotes the special characters (including \), and it introduces additional special constructs. Because \ quotes special characters, \$ is a regular expression that matches only $, and \[ is a regular expression that matches only [, and so on. See the following section for the special constructs that begin with \.

Note: for historical compatibility, special characters are treated as ordinary ones if they are in contexts where their special meanings make no sense. For example, *foo treats * as ordinary since there is no preceding expression on which the * can act. It is poor practice to depend on this behavior; it is better to quote the special character anyway, regardless of where it appears. As a \ is not special inside a bracket expression, it can never remove the special meaning of -, ^ or ]. You should not quote these characters when they have no special meaning. This would not clarify anything, since backslashes can legitimately precede these characters where they have special meaning, as in [^\] ("[^\\]" for Lisp string syntax), which matches any single character except a backslash.

For the most part, \ followed by any character matches only that character. However, there are several exceptions: two-character sequences starting with \ that have special meanings. The second character in the sequence is always an ordinary character when used on its own. Here is a table of \ constructs.

\|

specifies an alternative. Two regular expressions a and b with \| in between form an expression that matches some text if either a matches it or b matches it. It works by trying to match a, and if that fails, by trying to match b. Thus, foo\|bar matches either foo or bar but no other string. \| applies to the largest possible surrounding expressions. Only a surrounding \( ... \) grouping can limit the grouping power of \|. Full backtracking capability exists to handle multiple uses of \|.

\( ... \)

is a grouping construct that serves three purposes:

?

:: To enclose a set of \| alternatives for other operations. Thus, \(foo\|bar\)x matches either foox or barx.

?

:: To enclose a complicated expression for the postfix operators *, + and ? to operate on. Thus, ba\(na\)* matches bananana, etc., with any (zero or more) number of na strings.

?

:: To record a matched substring for future reference. This last application is not a consequence of the idea of a parenthetical grouping; it is a separate feature that is assigned as a second meaning to the same \( ... \) construct. In practice there is usually no conflict between the two meanings; when there is a conflict, you can use a shy group, described below.

\(?: ... \)

specifies a shy group that does not record the matched substring; you can't refer back to it with \/d/ (see below). This is useful in mechanically combining regular expressions, so that you can add groups for syntactic purposes without interfering with the numbering of the groups that are meant to be referred to.

\d

matches the same text that matched the d/th occurrence of a \( ... \) construct. This is called a /back reference. After the end of a \( ... \) construct, the matcher remembers the beginning and end of the text matched by that construct. Then, later on in the regular expression, you can use \ followed by the digit d to mean "match the same text matched the /d/th \( ... \) construct". The strings matching the first nine \( ... \) constructs appearing in a regular expression are assigned numbers 1 through 9 in the order that the open-parentheses appear in the regular expression. So you can use \1 through \9 to refer to the text matched by the corresponding \( ... \) constructs. For example, \(.*\)\1 matches any newline-free string that is composed of two identical halves. The \(.*\) matches the first half, which may be anything, but the \1 that follows must match the same exact text. If a particular \( ... \) construct matches more than once (which can easily happen if it is followed by *), only the last match is recorded.

\@{m\@}

is a postfix operator specifying m repetitions—that is, the preceding regular expression must match exactly m times in a row. For example, x\@{4\@} matches the string xxxx and nothing else.

\@{m,n\@}

is a postfix operator specifying between m and n repetitions—that is, the preceding regular expression must match at least m times, but no more than n times. If n is omitted, then there is no upper limit, but the preceding regular expression must match at least m times. \@{0,1\@} is equivalent to ?. \@{0,\@} is equivalent to *. \@{1,\@} is equivalent to +.

\`

matches the empty string, but only at the beginning of the string or buffer (or its accessible portion) being matched against.

\'

matches the empty string, but only at the end of the string or buffer (or its accessible portion) being matched against.

\=

matches the empty string, but only at point.

\b

matches the empty string, but only at the beginning or end of a word. Thus, \bfoo\b matches any occurrence of foo as a separate word. \bballs?\b matches ball or balls as a separate word. \b matches at the beginning or end of the buffer regardless of what text appears next to it.

\B

matches the empty string, but not at the beginning or end of a word.

\<

matches the empty string, but only at the beginning of a word. \< matches at the beginning of the buffer only if a word-constituent character follows.

\>

matches the empty string, but only at the end of a word. \> matches at the end of the buffer only if the contents end with a word-constituent character.

\w

matches any word-constituent character. The syntax table determines which characters these are. Syntax Tables.

\W

matches any character that is not a word-constituent.

\_<

matches the empty string, but only at the beginning of a symbol. A symbol is a sequence of one or more symbol-constituent characters. A symbol-constituent character is a character whose syntax is either w or _. \_< matches at the beginning of the buffer only if a symbol-constituent character follows. As with words, the syntax table determines which characters are symbol-constituent.

\_>

matches the empty string, but only at the end of a symbol. \_> matches at the end of the buffer only if the contents end with a symbol-constituent character.

\sc

matches any character whose syntax is c. Here c is a character that designates a particular syntax class: thus, w for word constituent, - or = for whitespace, =. for ordinary punctuation, etc. Syntax Class Table.

\Sc

matches any character whose syntax is not c.

\cc

matches any character that belongs to the category c. For example, \cc matches Chinese characters, \cg matches Greek characters, etc. For the description of the known categories, type M-x describe-categories RET.

\Cc

matches any character that does not belong to category c.

The constructs that pertain to words and syntax are controlled by the setting of the syntax table. Syntax Tables.

Here is an example of a regexp—similar to the regexp that Emacs uses, by default, to recognize the end of a sentence, not including the following space (i.e., the variable sentence-end-base):

@verbatim
[.?!][]\"')}]*
@end verbatim

This contains two parts in succession: a character set matching period, ?, or !, and a character set matching close-brackets, quotes, or parentheses, repeated zero or more times.

Normally, you'd want search commands to disregard certain minor differences between the search string you type and the text being searched. For example, sequences of whitespace characters of different length are usually perceived as equivalent; letter-case differences usually don't matter; etc. This is known as character equivalence. This section describes the Emacs lax search features, and how to tailor them to your needs. By default, search commands perform lax space matching: each space, or sequence of spaces, matches any sequence of one or more whitespace characters in the text. More precisely, Emacs matches each sequence of space characters in the search string to a regular expression specified by the user option search-whitespace-regexp. The default value of this option considers any sequence of spaces and tab characters as whitespace. Hence, foo bar matches foo bar, foo@ @ bar, foo@ @ @ bar, and so on (but not foobar). If you want to make spaces match sequences of newlines as well as spaces and tabs, customize the option to make its value be the regular expression [ \t\n]+. (The default behavior of the incremental regexp search is different; see Regexp Search.) If you want whitespace characters to match exactly, you can turn lax space matching off by typing M-s SPC (isearch-toggle-lax-whitespace) within an incremental search. Another M-s SPC turns lax space matching back on. To disable lax whitespace matching for all searches, change search-whitespace-regexp to nil; then each space in the search string matches exactly one space. Searches in Emacs by default ignore the case of the text they are searching through, if you specify the search string in lower case. Thus, if you specify searching for foo, then Foo and fOO also match. Regexps, and in particular character sets, behave likewise: [ab] matches a or A or b or B. This feature is known as case folding, and it is supported in both incremental and non-incremental search modes. An upper-case letter anywhere in the search string makes the search case-sensitive. Thus, searching for Foo does not find foo or FOO. This applies to regular expression search as well as to literal string search. The effect ceases if you delete the upper-case letter from the search string. The variable search-upper-case controls this: if it is non-nil, an upper-case character in the search string makes the search case-sensitive; setting it to nil disables this effect of upper-case characters. The default value of this variable is not-yanks, which makes search case-sensitive if there are upper-case letters in the search string, and also causes text yanked into the search string (Isearch Yank) to be down-cased, so that such searches are case-insensitive by default. If you set the variable case-fold-search to nil, then all letters must match exactly, including case. This is a per-buffer variable; altering the variable normally affects only the current buffer, unless you change its default value. Locals. This variable applies to nonincremental searches also, including those performed by the replace commands (Replace) and the minibuffer history matching commands (Minibuffer History). Typing M-c or M-s c (isearch-toggle-case-fold) within an incremental search toggles the case sensitivity of that search. The effect does not extend beyond the current incremental search, but it does override the effect of adding or removing an upper-case letter in the current search. Several related variables control case-sensitivity of searching and matching for specific commands or activities. For instance, tags-case-fold-search controls case sensitivity for find-tag. To find these variables, do M-x apropos-variable =RET case-fold-search RET=. Case folding disregards case distinctions among characters, making upper-case characters match lower-case variants, and vice versa. A generalization of case folding is character folding, which disregards wider classes of distinctions among similar characters. For instance, under character folding the letter a matches all of its accented cousins like @"a and @'a, i.e., the match disregards the diacritics that distinguish these variants. In addition, a matches other characters that resemble it, or have it as part of their graphical representation, such as U+00AA @sc{feminine ordinal indicator} and U+24D0 @sc{circled latin small letter a} (which looks like a small a inside a circle). Similarly, the ASCII double-quote character " matches all the other variants of double quotes defined by the Unicode standard. Finally, character folding can make a sequence of one or more characters match another sequence of a different length: for example, the sequence of two characters ff matches U+FB00 @sc{latin small ligature ff} and the sequence (a) matches U+249C @sc{parenthesized latin small letter a}. Character sequences that are not identical, but match under character folding are known as equivalent character sequences. Generally, search commands in Emacs do not by default perform character folding in order to match equivalent character sequences. You can enable this behavior by customizing the variable search-default-mode to char-fold-to-regexp. Search Customizations. Within an incremental search, typing M-s ' (isearch-toggle-char-fold) toggles character folding, but only for that search. (Replace commands have a different default, controlled by a separate option; see Replacement and Lax Matches.) By default, typing an explicit variant of a character, such as @"a, as part of the search string doesn't match its base character, such as a. But if you customize the variable char-fold-symmetric to t, then search commands treat equivalent characters the same and use of any of a set of equivalent characters in a search string finds any of them in the text being searched, so typing an accented character @"a matches the letter a as well as all the other variants like @'a. You can add new foldings using the customizable variable char-fold-include, or remove the existing ones using the customizable variable char-fold-exclude. You can also customize char-fold-override to t to disable all the character equivalences except those you add yourself using char-fold-include.

Emacs provides several commands for performing search-and-replace operations. In addition to the simple M-x replace-string command, there is M-% (query-replace), which presents each occurrence of the search pattern and asks you whether to replace it. The replace commands normally operate on the text from point to the end of the buffer. When the region is active, they operate on it instead (Mark). The basic replace commands replace one search string (or regexp) with one replacement string. It is possible to perform several replacements in parallel, using the command expand-region-abbrevs (Expanding Abbrevs).

M-x replace-regexp @key{RET} c[ad]+r @key{RET} \&-safe @key{RET}

M-x replace-regexp @key{RET} \(c[ad]+r\)-safe @key{RET} \1 @key{RET}

M-x replace-regexp @key{RET} \(x\)\|y @key{RET}
\,(if \1 "y" "x") @key{RET}

M-x replace-regexp @key{RET} ^.\@{0,72\@}$ @key{RET}
\,(format "%-72sABC%05d" \& \#) @key{RET}

M-x replace-string @key{RET} foo @key{RET} bar @key{RET}

M-x replace-string @key{RET} foo bar @key{RET} baz quux @key{RET}

Here are some other commands that find matches for regular expressions. They all ignore case in matching, if the pattern contains no upper-case letters and case-fold-search is non-nil. Aside from multi-occur and multi-occur-in-matching-buffers, which always search the whole buffer, all of the commands operate on the text from point to the end of the buffer, or on the region if it is active.

M-x multi-isearch-buffers

Prompt for one or more buffer names, ending with RET; then, begin a multi-buffer incremental search in those buffers. (If the search fails in one buffer, the next C-s tries searching the next specified buffer, and so forth.) With a prefix argument, prompt for a regexp and begin a multi-buffer incremental search in buffers matching that regexp.

M-x multi-isearch-buffers-regexp

This command is just like multi-isearch-buffers, except it performs an incremental regexp search.

M-x multi-isearch-files

Prompt for one or more file names, ending with RET; then, begin a multi-file incremental search in those files. (If the search fails in one file, the next C-s tries searching the next specified file, and so forth.) With a prefix argument, prompt for a regexp and begin a multi-file incremental search in files matching that regexp.

M-x multi-isearch-files-regexp

This command is just like multi-isearch-files, except it performs an incremental regexp search. In some modes that set the buffer-local variable multi-isearch-next-buffer-function (e.g., in Change Log mode) a multi-file incremental search is activated automatically.

M-x occur, M-s o

Prompt for a regexp, and display a list showing each line in the buffer that contains a match for it. If you type M-n at the prompt, you can reuse search strings from previous incremental searches. The text that matched is highlighted using the match face. A numeric argument n specifies that n lines of context are to be displayed before and after each matching line. The default number of context lines is specified by the variable list-matching-lines-default-context-lines. When list-matching-lines-jump-to-current-line is non-nil the current line is shown highlighted with face list-matching-lines-current-line-face and the point is set at the first match after such line. You can also run M-s o when an incremental search is active; this uses the current search string. Note that matches for the regexp you type are extended to include complete lines, and a match that starts before the previous match ends is not considered a match. The *Occur* buffer uses the Occur mode as its major mode. You can use the n and p keys to move to the next or previous match; with prefix numeric argument, these commands move that many matches. Digit keys are bound to digit-argument, so 5 n moves to the fifth next match (you don't have to type C-u). SPC and DEL scroll the *Occur* buffer up and down. Clicking on a match or moving point there and typing RET visits the corresponding position in the original buffer that was searched. o and C-o display the match in another window; C-o does not select that window. Alternatively, you can use the M-g M-n (next-error) command to visit the occurrences one by one (Compilation Mode). Finally, q quits the window showing the *Occur* buffer and buries the buffer. Typing e in the *Occur* buffer makes the buffer writable and enters the Occur Edit mode, in which you can edit the matching lines and have those edits reflected in the text in the originating buffer. Type C-c C-c to leave the Occur Edit mode and return to the Occur mode. The command M-x list-matching-lines is a synonym for M-x occur.

M-x multi-occur

This command is just like occur, except it is able to search through multiple buffers. It asks you to specify the buffer names one by one.

M-x multi-occur-in-matching-buffers

This command is similar to multi-occur, except the buffers to search are specified by a regular expression that matches visited file names. With a prefix argument, it uses the regular expression to match buffer names instead.

M-x how-many

Prompt for a regexp, and print the number of matches for it in the buffer after point. If the region is active, this operates on the region instead.

M-x flush-lines

Prompt for a regexp, and delete each line that contains a match for it, operating on the text after point. When the command finishes, it prints the number of deleted matching lines. This command deletes the current line if it contains a match starting after point. If the region is active, it operates on the region instead; if a line partially contained in the region contains a match entirely contained in the region, it is deleted. If a match is split across lines, flush-lines deletes all those lines. It deletes the lines before starting to look for the next match; hence, it ignores a match starting on the same line at which another match ended.

M-x keep-lines

Prompt for a regexp, and delete each line that does not contain a match for it, operating on the text after point. If point is not at the beginning of a line, this command always keeps the current line. If the region is active, the command operates on the region instead; it never deletes lines that are only partially contained in the region (a newline that ends a line counts as part of that line). If a match is split across lines, this command keeps all those lines.

M-x kill-matching-lines

Like flush-lines, but also add the matching lines to the kill ring. The command adds the matching lines to the kill ring as a single string, including the newlines that separated the lines.

M-x copy-matching-lines

Like kill-matching-lines, but the matching lines are not removed from the buffer.

This section describes miscellaneous search-related customizations not described elsewhere. The default search mode for the incremental search is specified by the variable search-default-mode. It can be nil, t, or a function. If it is nil, the default mode is to do literal searches without character folding, but with case folding and lax-whitespace matches as determined by case-fold-search and search-whitespace-regexp, respectively (Lax Search). If the value is t, incremental search defaults to regexp searches. The default value specifies a function that only performs case folding and lax-whitespace matching. The current match of an on-going incremental search is highlighted using the isearch face. This highlighting can be disabled by setting the variable search-highlight to nil. When searching for regular expressions (with C-M-s, for instance), subexpressions receive special highlighting depending on the search-highlight-submatches variable. If this variable's value is nil, no special highlighting is done, but if the value is non-nil, text that matches \( ... \) constructs (a.k.a. "subexpressions") in the regular expression will be highlighted with distinct faces. By default, two distinct faces are defined, named isearch-group-1 and isearch-group-2. With these two faces, odd-numbered subexpressions will be highlighted using the isearch-group-1 face and even-numbered subexpressions will be highlighted using the isearch-group-2 face. For instance, when searching for foo-\([0-9]+\)\([a-z]+\), the part matched by [0-9]+ will be highlighted with the isearch-group-1 face, and the part matched by [a-z]+ will be highlighted using isearch-group-2. If you define additional faces using the same numbering scheme, i.e. isearch-group-3, isearch-group-4, …, then the face isearch-group-M will be used to highlight the M'th, N+M'th, 2N+M'th, … subexpressions, where N is the total number of faces of the form isearch-group-M. The other matches for the search string that are visible on display are highlighted using the lazy-highlight face. Setting the variable isearch-lazy-highlight to nil disables this highlighting. Here are some other variables that customize the lazy highlighting:

lazy-highlight-initial-delay

Time in seconds to wait before highlighting visible matches. Applies only if the search string is less than lazy-highlight-no-delay-length characters long.

lazy-highlight-no-delay-length

For search strings at least as long as the value of this variable, lazy highlighting of matches starts immediately.

lazy-highlight-interval

Time in seconds between highlighting successive matches.

lazy-highlight-max-at-a-time

The maximum number of matches to highlight before checking for input. A large number can take some time to highlight, so if you want to continue searching and type C-s or C-r during that time, Emacs will not respond until it finishes highlighting all those matches. Thus, smaller values make Emacs more responsive.

isearch-lazy-count

Show the current match number and the total number of matches in the search prompt.

lazy-count-prefix-format, lazy-count-suffix-format

These two variables determine the format of showing the current and the total number of matches for isearch-lazy-count.

Normally, entering RET within incremental search when the search string is empty launches a nonincremental search. (Actually, it lets you edit the search string, and the next RET does the search.) However, if you customize the variable search-nonincremental-instead to nil, typing RET will always exit the incremental search, even if the search string is empty. By default, incremental search and query-replace commands match invisible text, but hide any such matches as soon as the current match moves off the invisible text. If you customize the variable isearch-hide-immediately to nil, any invisible text where matches were found stays on display until the search or the replace command exits. Searching incrementally on slow terminals, such as displays connected to remote machines over slow connection, could be annoying due to the need to redraw large portions of the display as the search proceeds. Emacs provides a special display mode for slow terminals, whereby search pops up a separate small window and displays the text surrounding the match in that window. Small windows display faster, so the annoying effect of slow speed is alleviated. The variable search-slow-speed determines the baud rate threshold below which Emacs will use this display mode. The variable search-slow-window-lines controls the number of lines in the window Emacs pops up for displaying the search results; the default is 1 line. Normally, this window will pop up at the bottom of the window that displays the buffer where you start searching, but if the value of search-slow-window-lines is negative, that means to put the window at the top and give it the number of lines that is the absolute value of search-slow-window-lines.