vi Complete Key Binding List

This is not intended as a tutorial. It is a reference on what every vi
key binding does, followed by some useful vi tricks and tips. An expert will
probably know most of these already, but an intermediate vi user will find
valuable information, and even an expert may learn a thing or two.

word - a lower-case word ("w", "b", "e" commands)
is defined by a consecutive string of
letters, numbers, or underscore, or a consecutive string of characters
that is not any of {letters, numbers, underscore, whitespace}

cursor motion command - any command which positions the cursor is
ok here,
including the use of numeric prefixes. In addition, a repeat of the edit
command usually means to apply to the entire current line. For example,
"<<" means shift current line left; "cc" means
replace entire current line; and "dd" means delete entire current line.

Key Bindings in Editing Modes

While in any edit mode (insert, replace, etc.) there are some keys that
are used to adjust behaviour, rather than just to insert text.

ESC - leave edit mode, return to command mode

^D - move line backwards one shiftwidth. shiftwidth must be set, and
either the line must be newly added, or ^T must have been used.

^T - move all after cursor forwards one shiftwidth

^H - deletes text that was entered during the current edit mode.
Most versions of vi do not allow deleting to previous line.

Most commands can be prefixed with a multidigit number, that influences the
way the command works.

z

position nth line number

G

goto nth line number

|

goto nth column number

r

replace next n characters

s

substitute for next n characters

<<

shift n lines left one shiftwidth

^

ignored?

_

advance n-1 lines

Need to differentiate between such things as 5yj vs. y5j?

Multibuffer

Standard vi does have an ability to toggle between two different files.
These will be the last two edited files (edit new files with :efilename)
To switch files, use control-^.

These filenames can be reffered to in ex commands, and subshell filters,
using two special characters: "%" refers to the current file, and "#"
refers to the previous file. Here's some handy things you can do with
this feature:

Tags

Mappings and Abbreviations

:map lets you bind a list of keystrokes to a shortcut in command-mode.
This shortcut can be a multiple-key sequence (with limitations),
and the commands within can enter and exit edit-mode.
Some examples of :map can be found above, in the multibuffer section.
Below is a list of all the normally unbound keys in vi command-mode.

g q v K V # * \ = ^A ^C ^I ^K ^O ^V ^W ^X ^[ ^_

When you try to map multiple key sequences, you won't be able to start
them with lower or upper case letters ("Too dangerous to map that"),
but the punctuation and control characters are fair game.
In addition, : can't be mapped, and sometimes a few other keys. Multiple
key sequences can also be very useful with terminal-generated sequences,
which is why the escape key is bindable. I have my xterm set to generate
=f1 for function key one, and so on, so all the function keys are easier to
use with bindings.

If you use multiple key shortcuts, you'll want to know about the timeout
variable. With :se timeout, you have a limited time to generate
the key sequence. This is useful if the key sequences are terminal generated.
With :se notimeout, it just keeps waiting until the next character
does or doesn't match any possible current sequences.

:map! lets you bind a list of keystrokes to a shortcut in edit-mode.
This is useful for adding editing commands to edit mode. One popular
trick is to bind the arrow keys to move up and down while (apparently)
staying in edit-mode, as in the last four lines below.

If you use the above
trick for arrow-keys in edit-mode, you'll want to set timeout, because
otherwise you won't get beeps at all when you hit escape, only when you
use the next keystroke. With timeout, you get the beep, but after the
timeout. Since both of these are annoying, it may be a useful choice to
avoid multikey sequences that involve escape, as a matter of taste.
Also, many systems now set up command-mode arrow keys in vi by default,
which also leads to the same problem.

:ab lets you bind a key sequence to an abbreviation,
for use in edit-mode.
Abbreviations don't fire until vi decides that you've typed the shortcut
as a whole word. So if taf is a shortcut for Thomas A. Fine, and I type
taffy, it won't substitute because I didn't enter taf as a word by itself.
(If I'd used :map!, then taffy would do the
replacement before I got to the second "f".)

Abbreviations are echoed normally until complete, therefore the abbreviation
can't contain escape (you'd leave edit-mode before completing the
abbreviation),
but the replacement expression can contain escape, and can leave and return
to edit-mode.

To keep a live abbreviation from going off in your hands, use ^V. For
instance, if I want to type teh but have the the abbreviation above, I
can let it "fix" it, then back up and unfix it; or I can type "teh^V..."
and it won't expand the abbreviatoin.

Repeating with .

Commands can be repeated with the redo command, normally bound to ".",
but I've found this to be occasionally unpredictable. If you use multiple
key sequences in a macro, and vi is waiting to see if one of those sequences
might complete, and you start a new command here, it won't be noticed by
the redo. (Solaris, HPUX at least).

System Differences

Older versions of vi didn't automatically set up arrow-keys in
command-mode; they didn't interfere with the beep. (Maybe multiple
key bindings were new at the same time???)

Some versions of vi have encryption, some don't.

Options processing is handled differently from version to version.
Solaris prefers -c command in place of +command, and
-L instead of -r.

Differnt systems may have other keys besides : that are "Too dangerous
to map that".

The size of macros (:map, etc.) are limited in different ways on different
systems.

On some systems the environment variable EXINIT overrides .exrc files (Solaris, HPUX), other systems it enhances it (SunOS???, FreeBSD).

nvi allows backspace to previous line in edit-mode (if previous line was edited) (FreeBSD).

variants of vi that have multiple undo have different styles. One style
(linux) uses u as undo, and control-R as redo. The other style (FreeBSD)
u acts normally, but . continues on in the same direction as the last u
(whether it was undo or redo). I prefer the latter because it doesn't
interfere as much with traditional vi behaviour.

Note the control-v's are there to enter the following characters, which would
otherwise terminate the map command. The above was written as you have to
enter the special characters in traditional vi. In vim, you can use the
four literal characters "<CR>" for a carriage return, and also
"<Esc>" for Escape. So it may be easier to type this, and it can
also go into your .vimrc) more readibly (with thanks to
Bart Van den Broeck):

:map v 0ma}b:'a,.j<CR>070 ? *<Esc>dwi<CR><Esc>

It's better because you don't have to prejoin the paragraph by hitting J
an arbitrary number of times. Just hit v (or whatever you've mapped it to)
starting at the beginning or in the middle of the paragraph, and it joines the
rest of the paragraph together, formats one line, and moves the cursor down
again. Just keep hitting v and it will keep formatting. You have to stop one
before the end or you'll end up with an extra short line. It also does not
leave spaces at the end of the line.