GNU Emacs Manual - Incremental Search

Go to the first, previous, next, last section, table of contents.

## Incremental Search

An incremental search 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`).

`C-s` starts an incremental search. `C-s` reads characters from the keyboard and positions the cursor at the first occurrence of the characters that you have typed. If you type `C-s` and then `F`, the cursor moves right after the first ``F'`. Type an `O`, and see the cursor move to after the first ``FO'`. After another `O`, the cursor is after the first ``FOO'` after the place where you started the search. At each step, the buffer text that matches the search string is highlighted, if the terminal can do that; at each step, the current search string is updated in the echo area.

If you make a mistake in typing the search string, you can cancel characters with `DEL`. Each `DEL` cancels the last character of search string. This does not happen until Emacs is ready to read another input character; first it must either find, or fail to find, the character you want to erase. If you do not want to wait for this to happen, use `C-g` as described below.

When you are satisfied with the place you have reached, you can type `RET`, which stops searching, leaving the cursor where the search brought it. Also, any command not specially meaningful in searches stops the searching and is then executed. Thus, typing `C-a` would exit the search and then move to the beginning of the line. `RET` is necessary only if the next command you want to type is a printing character, `DEL`, `RET`, or another control character that is special within searches (`C-q`, `C-w`, `C-r`, `C-s`, `C-y`, `M-y`, `M-r`, or `M-s`).

Sometimes you search for ``FOO'` and find it, but not the one you expected to find. There was a second ``FOO'` that you forgot about, before the one you were aiming for. In this event, type another `C-s` to move to the next occurrence of the search string. This can be done any number of times. If you overshoot, you can cancel some `C-s` characters with `DEL`.

After you exit a search, you can search for the same string again by typing just `C-s C-s`: the first `C-s` is the key that invokes incremental search, and the second `C-s` means "search again."

To reuse earlier search strings, use the search ring. The commands `M-p` and `M-n` move through the ring to pick a search string to reuse. These commands leave the selected search ring element in the minibuffer, where you can edit it. Type `C-s` or `C-r` to terminate editing the string and search for it.

If your string is not found at all, the echo area says ``Failing I-Search'`. The cursor is after the place where Emacs found as much of your string as it could. Thus, if you search for ``FOOT'`, and there is no ``FOOT'`, you might see the cursor after the ``FOO'` in ``FOOL'`. At this point there are several things you can do. If your string was mistyped, you can rub some of it out and correct it. If you like the place you have found, you can type `RET` or some other Emacs command to "accept what the search offered." Or you can type `C-g`, which removes from the search string the characters that could not be found (the ``T'` in ``FOOT'`), leaving those that were found (the ``FOO'` in ``FOOT'`). A second `C-g` at that point cancels the search entirely, returning point to where it was when the search started.

An upper-case letter in the search string makes the search case-sensitive. If you delete the upper-case character from the search string, it ceases to have this effect. See section Searching and Case.

If a search is failing and you ask to repeat it by typing another `C-s`, it starts again from the beginning of the buffer. Repeating a failing reverse search with `C-r` starts again from the end. This is called wrapping around. ``Wrapped'` appears in the search prompt once this has happened. If you keep on going past the original starting point of the search, it changes to ``Overwrapped'`, which means that you are revisiting matches that you have already seen.

The `C-g` "quit" character does special things during searches; just what it does depends on the status of the search. If the search has found what you specified and is waiting for input, `C-g` cancels the entire search. The cursor moves back to where you started the search. If `C-g` is typed when there are characters in the search string that have not been found--because Emacs is still searching for them, or because it has failed to find them--then the search string characters which have not been found are discarded from the search string. With them gone, the search is now successful and waiting for more input, so a second `C-g` will cancel the entire search.

To search for a newline, type `C-j`. To search for another control character, such as control-S or carriage return, you must quote it by typing `C-q` first. This function of `C-q` is analogous to its use for insertion (see section Inserting Text): it causes the following character to be treated the way any "ordinary" character is treated in the same context. You can also specify a character by its octal code: enter `C-q` followed by a sequence of octal digits.

You can change to searching backwards with `C-r`. If a search fails because the place you started was too late in the file, you should do this. Repeated `C-r` keeps looking for more occurrences backwards. A `C-s` starts going forwards again. `C-r` in a search can be canceled with `DEL`.

If you know initially that you want to search backwards, you can use `C-r` instead of `C-s` to start the search, because `C-r` as a key runs a command (`isearch-backward`) to search backward. A backward search finds matches that are entirely before the starting point, just as a forward search finds matches that begin after it.

The characters `C-y` and `C-w` can be used in incremental search to grab text from the buffer into the search string. This makes it convenient to search for another occurrence of text at point. `C-w` copies the word after point as part of the search string, advancing point over that word. Another `C-s` to repeat the search will then search for a string including that word. `C-y` is similar to `C-w` but copies all the rest of the current line into the search string. Both `C-y` and `C-w` convert the text they copy to lower case if the search is currently not case-sensitive; this is so the search remains case-insensitive.

The character `M-y` copies text from the kill ring into the search string. It uses the same text that `C-y` as a command would yank. See section Yanking.

When you exit the incremental search, it sets the mark to where point was, before the search. That is convenient for moving back there. In Transient Mark mode, incremental search sets the mark without activating it, and does so only if the mark is not already active.

To customize the special characters that incremental search understands, alter their bindings in the keymap `isearch-mode-map`. For a list of bindings, look at the documentation of `isearch-mode` with `C-h f isearch-mode `RET``.

### Slow Terminal Incremental Search

Incremental search on a slow terminal uses a modified style of display that is designed to take less time. Instead of redisplaying the buffer at each place the search gets to, it creates a new single-line window and uses that to display the line that the search has found. The single-line window comes into play as soon as point gets outside of the text that is already on the screen.

When you terminate the search, the single-line window is removed. Then Emacs redisplays the window in which the search was done, to show its new position of point.

The slow terminal style of display is used when the terminal baud rate is less than or equal to the value of the variable `search-slow-speed`, initially 1200.

The number of lines to use in slow terminal search display is controlled by the variable `search-slow-window-lines`. Its normal value is 1.

Go to the first, previous, next, last section, table of contents.