Next: Yanking Prev: Additional Mouse Operations Up: Top

Deletion and Killing

   Most commands that erase text from the buffer save it. You can get
the text back if you change your mind, or you can move or copy it to
other parts of the buffer.  Commands which erase text and save it in the
kill ring are known as "kill" commands.  Some other commands erase text
but do not save it; they are known as "delete" commands.  (This
distinction is made only for erasing text in the buffer.)

   The commands' names and individual descriptions use the words `kill'
and `delete' to indicate what they do.  If you perform a kill or delete
command by mistake, use the `C-x u' (`undo') command to undo it (*note
Undo::.). The delete commands include `C-d' (`delete-char') and DEL
(`delete-backward-char'), which delete only one character at a time,
and those commands that delete only spaces or newlines.  Commands that
can destroy significant amounts of nontrivial data usually kill.


     Delete next character (`delete-char').

     Delete previous character (`delete-backward-char').

     Delete spaces and tabs around point (`delete-horizontal-space').

     Delete spaces and tabs around point, leaving one space

`C-x C-o'
     Delete blank lines around the current line (`delete-blank-lines').

     Join two lines by deleting the intervening newline, and any
     indentation following it (`delete-indentation').

   The most basic delete commands are `C-d' (`delete-char') and DEL
(`delete-backward-char').  `C-d' deletes the character after point, the
one the cursor is "on top of".  Point doesn't move.  DEL deletes the
character before the cursor, and moves point back.  You can delete
newlines like any other characters in the buffer; deleting a newline
joins two lines.  Actually, `C-d' and DEL aren't always delete
commands; if you give them an argument, they kill instead, since they
can erase more than one character this way.

   The other delete commands delete only formatting characters: spaces,
tabs and newlines.  `M-\' (`delete-horizontal-space') deletes all
spaces and tab characters before and after point.  `M-SPC'
(`just-one-space') does the same but leaves a single space after point,
regardless of the number of spaces that existed previously (even zero).

   `C-x C-o' (`delete-blank-lines') deletes all blank lines after the
current line. If the current line is blank, it deletes all blank lines
preceding the current line as well as leaving one blank line, the
current line.  `M-^' (`delete-indentation') joins the current line and
the previous line, or, if given an argument, joins the current line and
the next line by deleting a newline and all surrounding spaces, possibly
leaving a single space.  Note: M-^.

Killing by Lines

     Kill rest of line or one or more lines (`kill-line').

   The simplest kill command is `C-k'.  If given at the beginning of a
line, it kills all the text on the line, leaving the line blank.  If
given on a blank line, the blank line disappears.  As a consequence, a
line disappears completely if you go to the front of a non-blank line
and type `C-k' twice.

   More generally, `C-k' kills from point up to the end of the line,
unless it is at the end of a line.  In that case, it kills the newline
following the line, thus merging the next line into the current one.
Emacs ignores invisible spaces and tabs at the end of the line when
deciding which case applies: if point appears to be at the end of the
line, you can be sure the newline will be killed.

   If you give `C-k' a positive argument, it kills that many lines and
the newlines that follow them (however, text on the current line before
point is not killed).  With a negative argument, `C-k' kills back to a
number of line beginnings.  An argument of -2 means kill back to the
second line beginning.  If point is at the beginning of a line, that
line beginning doesn't count, so `C-u - 2 C-k' with point at the front
of a line kills the two previous lines.

   `C-k' with an argument of zero kills all the text before point on the
current line.

Other Kill Commands

     Kill region (from point to the mark) (`kill-region').  *Note

     Kill word (`kill-word').

     Kill word backwards (`backward-kill-word').

`C-x DEL'
     Kill back to beginning of sentence (`backward-kill-sentence').
     Note: Sentences.

     Kill to end of sentence (`kill-sentence').

     Kill sexp (`kill-sexp').  Note: Lists.

`M-z CHAR'
     Kill up to next occurrence of CHAR (`zap-to-char').

   `C-w' (`kill-region') is a very general kill command; it kills
everything between point and the mark. You can use this command to kill
any contiguous sequence of characters by first setting the mark at one
end of a sequence of characters, then going to the other end and typing

   A convenient way of killing is combined with searching: `M-z'
(`zap-to-char') reads a character and kills from point up to (but not
including) the next occurrence of that character in the buffer.  If
there is no next occurrence, killing goes to the end of the buffer.  A
numeric argument acts as a repeat count.  A negative argument means to
search backward and kill text before point.

   Other syntactic units can be killed: words, with `M-DEL' and `M-d'
(Note: Words.); sexps, with `C-M-k' (Note: Lists.); and sentences,
with `C-x DEL' and `M-k' (Note: Sentences.).

automatically generated by info2www