Go to the previous, next section.
We now give the basics of how to enter text, make corrections, and
save the text in a file. If this material is new to you, you might
learn it more easily by running the Emacs learn-by-doing tutorial. To
do this, type Control-h t (help-with-tutorial).
To insert printing characters into the text you are editing, just type them. This inserts the character into the buffer at the cursor (that is, at point; see section Point). The cursor moves forward. Any characters after the cursor move forward too. If the text in the buffer is `FOOBAR', with the cursor before the `B', then if you type XX, you get `FOOXXBAR', with the cursor still before the `B'.
To delete text you have just inserted, use DEL. DEL deletes the character before the cursor (not the one that the cursor is on top of or under; that is the character after the cursor). The cursor and all characters after it move backwards. Therefore, if you type a printing character and then type DEL, they cancel out.
To end a line and start typing a new one, type RET. This inserts a newline character in the buffer. If point is in the middle of a line, RET splits the line. Typing DEL when the cursor is at the beginning of a line rubs out the newline before the line, thus joining the line with the preceding line.
Emacs will split lines automatically when they become too long, if you turn on a special mode called Auto Fill mode. See section Filling Text, for how to use Auto Fill mode.
Customization information: DEL in most modes runs the command named
delete-backward-char; RET runs the command newline, and
self-inserting printing characters run the command self-insert,
which inserts whatever character was typed to invoke it. Some major modes
rebind DEL to other commands.
Direct insertion works for printing characters and SPC, but other
characters act as editing commands and do not insert themselves. If you
need to insert a control character or a character whose code is above 200
octal, you must quote it by typing the character control-q
(quoted-insert) first. There are two ways to use C-q:
A numeric argument to C-q specifies how many copies of the quoted character should be inserted (see section Numeric Arguments).
If you prefer to have text characters replace (overwrite) existing text rather than shove it to the right, you can enable Overwrite mode, a minor mode. See section Minor Modes.
To do more than insert characters, you have to know how to move point (see section Point). Here are a few of the commands for doing that.
beginning-of-line).
end-of-line).
forward-char).
backward-char).
forward-word).
backward-word).
next-line). This command
attempts to keep the horizontal position unchanged, so if you start in
the middle of one line, you end in the middle of the next. When on
the last line of text, C-n creates a new line and moves onto it.
previous-line).
recenter). Text moves
on the screen to bring point to the center of the window.
move-to-window-line). Text does not move on the
screen. A numeric argument says how many screen lines down from the
top of the window (zero for the top). A negative argument counts from
the bottom (-1 for the bottom).
transpose-chars).
beginning-of-buffer). With
numeric argument n, move to n/10 of the way from the top.
See section Numeric Arguments, for more information on numeric arguments.end-of-buffer).
set-goal-column). Henceforth, those
commands always move to this column in each line moved into, or as
close as possible given the contents of the line. This goal column remains
in effect until canceled.
If you set the variable track-eol to a non-nil value, then
C-n and C-p when at the end of the starting line move to the
end of the line. Normally, track-eol is nil.
delete-backward-char).
delete-char).
kill-line).
kill-word).
backward-kill-word).
You already know about the DEL key which deletes the character before the cursor. Another key, Control-d, deletes the character after the cursor, causing the rest of the text on the line to shift left. If Control-d is typed at the end of a line, that line and the next line are joined together.
To erase a larger amount of text, use the Control-k key, which kills a line at a time. If C-k is done at the beginning or middle of a line, it kills all the text up to the end of the line. If C-k is done at the end of a line, it joins that line and the next line.
See section Deletion and Killing, for more flexible ways of killing text.
The commands above are sufficient for creating and altering text in an Emacs buffer; the more advanced Emacs commands just make things easier. But to keep any text permanently you must put it in a file. Files are named units of text which are stored by the operating system for you to retrieve later by name. To look at or use the contents of a file in any way, including editing the file with Emacs, you must specify the file name.
Consider a file named `/usr/rms/foo.c'. In Emacs, to begin editing this file, type
C-x C-f /usr/rms/foo.c RET
Here the file name is given as an argument to the command C-x
C-f (find-file). That command uses the minibuffer to
read the argument, and you type RET to terminate the argument
(see section The Minibuffer).
Emacs obeys the command by visiting the file: creating a buffer,
copying the contents of the file into the buffer, and then displaying the
buffer for you to edit. You can make changes in it, and then save
the file by typing C-x C-s (save-buffer). This makes the
changes permanent by copying the altered contents of the buffer back into
the file `/usr/rms/foo.c'. Until then, the changes are only inside
your Emacs, and the file `foo.c' is not changed.
To create a file, just visit the file with C-x C-f as if it already existed. Emacs will make an empty buffer in which you can insert the text you want to put in the file. When you save your text with C-x C-s, the file will be created.
Of course, there is a lot more to learn about using files. See section File Handling.
If you forget what a key does, you can find out with the Help character,
which is C-h. Type C-h k followed by the key you want to know
about; for example, C-h k C-n tells you all about what C-n
does. C-h is a prefix key; C-h k is just one of its
subcommands (the command describe-key). The other subcommands of
C-h provide different kinds of help. Type C-h three times
to get a description of all the help facilities. See section Help.
Here are special commands and techniques for putting in and taking out blank lines.
open-line).
delete-blank-lines).
When you want to insert a new line of text before an existing line, you
can do it by typing the new line of text, followed by RET. However,
it may be easier to see what you are doing if you first make a blank line
and then insert the desired text into it. This is easy to do using the key
C-o (open-line), which inserts a newline after point but leaves
point in front of the newline. After C-o, type the text for the new
line. C-o F O O has the same effect as F O O RET, except for
the final location of point.
You can make several blank lines by typing C-o several times, or by giving it an argument to tell it how many blank lines to make. See section Numeric Arguments, for how.
If you have many blank lines in a row and want to get rid of them, use
C-x C-o (delete-blank-lines). When point is on a blank line which
is adjacent to at least one other blank line, C-x C-o deletes all but
one of the consecutive blank lines, leaving exactly one. With point on a
blank line with no other blank line adjacent to it, the sole blank line is
deleted, leaving none. When point is on a nonblank line, C-x C-o
deletes any blank lines following that nonblank line.
If you add too many characters to one line, without breaking it with a RET, the line will grow to occupy two (or more) lines on the screen, with a `\' at the extreme right margin of all but the last of them. The `\' says that the following screen line is not really a distinct line in the text, but just the continuation of a line too long to fit the screen. Sometimes it is nice to have Emacs insert newlines automatically when a line gets too long; for this, use Auto Fill mode (see section Filling Text).
Instead of continuation, long lines can be displayed by truncation. This means that all the characters that do not fit in the width of the screen or window do not appear at all. They remain in the buffer, temporarily invisible. `$' is used in the last column instead of `\' to inform you that truncation is in effect.
Continuation can be turned off for a particular buffer by setting the
variable truncate-lines to non-nil in that buffer.
Truncation instead of continuation also happens whenever horizontal
scrolling is in use, and optionally whenever side-by-side windows are in
use (see section Multiple Windows). Altering the value of truncate-lines makes
it local to the current buffer; until that time, the default value is in
effect. The default is initially nil. See section Local Variables.
If you are accustomed to other display editors, you may be surprised that Emacs does not always display the page number or line number of point in the mode line. This is because the text is stored in a way that makes it difficult to compute this information. Displaying them all the time would be intolerably slow. They are not needed very often in Emacs anyway, but there are commands to compute them and print them.
count-lines-region).
what-cursor-position).
There are two commands for printing line numbers. M-x what-line counts lines from the beginning of the file and prints the line number point is on. The first line of the file is line number 1. These numbers can be used as arguments to M-x goto-line. By contrast, M-x what-page counts pages from the beginning of the file, and counts lines within the page, printing both of them. See section Pages.
While on this subject, we might as well mention M-= (count-lines-region),
which prints the number of lines in the region (see section The Mark and the Region).
See section Pages, for the command C-x l which counts the lines in the
current page.
The command C-x = (what-cursor-position) can be used to find out
the column that the cursor is in, and other miscellaneous information about
point. It prints a line in the echo area that looks like this:
Char: x (0170) point=65986 of 563027(12%) x=44
(In fact, this is the output produced when point is before the `x=44' in the example.)
The two values after `Char:' describe the character following point, first by showing it and second by giving its octal character code.
`point=' is followed by the position of point expressed as a character count. The front of the buffer counts as position 1, one character later as 2, and so on. The next, larger number is the total number of characters in the buffer. Afterward in parentheses comes the position expressed as a percentage of the total size.
`x=' is followed by the horizontal position of point, in columns from the left edge of the window.
If the buffer has been narrowed, making some of the text at the beginning and the end temporarily invisible, C-x = prints additional text describing the current visible range. For example, it might say
Char: x (0170) point=65986 of 563025(12%) <65102 - 68533> x=44
where the two extra numbers give the smallest and largest character position that point is allowed to assume. The characters between those two positions are the visible ones. See section Narrowing.
If point is at the end of the buffer (or the end of the visible part), C-x = omits any description of the character after point. The output looks like
point=563026 of 563025(100%) x=0
Any Emacs command can be given a numeric argument. Some commands
interpret the argument as a repetition count. For example, giving an
argument of ten to the key C-f (the command forward-char, move
forward one character) moves forward ten characters. With these commands,
no argument is equivalent to an argument of one. Negative arguments are
allowed. Often they tell a command to move or act backwards.
If your terminal keyboard has a META key, the easiest way to specify a numeric argument is to type digits and/or a minus sign while holding down the META key. For example,
M-5 C-nwould move down five lines. The characters Meta-1, Meta-2, and so on, as well as Meta--, do this because they are keys bound to commands (
digit-argument and negative-argument) that are
defined to contribute to an argument for the next command.
Another way of specifying an argument is to use the C-u
(universal-argument) command followed by the digits of the argument.
With C-u, you can type the argument digits without holding
down shift keys. To type a negative argument, start with a minus sign.
Just a minus sign normally means -1. C-u works on all terminals.
C-u followed by a character which is neither a digit nor a minus sign has the special meaning of "multiply by four". It multiplies the argument for the next command by four. C-u twice multiplies it by sixteen. Thus, C-u C-u C-f moves forward sixteen characters. This is a good way to move forward "fast", since it moves about 1/5 of a line in the usual size screen. Other useful combinations are C-u C-n, C-u C-u C-n (move down a good fraction of a screen), C-u C-u C-o (make "a lot" of blank lines), and C-u C-k (kill four lines).
Some commands care only about whether there is an argument, and not about
its value. For example, the command M-q (fill-paragraph) with
no argument fills text; with an argument, it justifies the text as well.
(See section Filling Text, for more information on M-q.) Just C-u is a
handy way of providing an argument for such commands.
Some commands use the value of the argument as a repeat count, but do
something peculiar when there is no argument. For example, the command
C-k (kill-line) with argument n kills n lines,
including their terminating newlines. But C-k with no argument is
special: it kills the text up to the next newline, or, if point is right at
the end of the line, it kills the newline itself. Thus, two C-k
commands with no arguments can kill a nonblank line, just like C-k
with an argument of one. (See section Deletion and Killing, for more information on
C-k.)
A few commands treat a plain C-u differently from an ordinary argument. A few others may treat an argument of just a minus sign differently from an argument of -1. These unusual cases will be described when they come up; they are always for reasons of convenience of use of the individual command.
To insert multiple copies of a digit, you can type C-u count C-u digit. The second C-u ends the numeric argument, so that the following character always acts a key sequence to be executed.
Go to the previous, next section.