VI Cheat

SYNTAX OF VI COMMANDS

Most commands in vi have the following form
[n] operator

Examples
5x	delete 5 characters
3fG	forward to third G on line
2tO	forward to character before second O on line
3Tc	backward to after the third c
20j	move cursor down 20 lines
5H	move cursor 5 lines from top of screen
5rx	replace next 5 characters with x
5$	move to end of 5th line down (line 1 is current)

Editing commands (c, d, y, >, <, !) have the following form
[n] operator [m] object
An object in vi would be a character or a word or a line or a sentence etc. Basic operators for editing are

c	begin a change
d	begin a delete
y	begin a yank

If the current line is the object of the operator then the object is the same as the operator: cc, dd, yy.
If both n and m are specified the effect is n * m, that is n multiplied by m.

Examples
cw	change word
c$	change to end of current line
5dd	delete next five lines
d5G	delete to line 5
dG	delete to end of file
de	delete to end of word
d^	delete to beginning of current line
yy	yank current line
y'z	yank to line marked with z
yL	yank to bottom of screen

Commands in vi are not echoed to the screen except the following.
These are echoed on the status line.

/	search forward for pattern
?	search backward for pattern
:	invoke an ex command
!	invoke a unix (OS) command that takes as its input an object in the buffer, and replaces it with output from the command

The above commands are completed by pressing the return key. A buffer in vi would refer to the file as it's kept in memory <, >, and ! can also be combined with a movement command like c, d, and y

Examples
>>	indent current line one shiftwidth
5<<	outdent 5 lines starting with current
/hello	search forward for word 'hello'

Back to top
(Part I/b)

QUICK HELP

( commands and command combinations to get you started in vi )

MOVEMENT
by character
h	cursor left
j	cursor down
k	cursor up
l	cursor right
space	cursor right
by line
[n]G	to line n
0, $	first, last position on line
+, -	first character on next, previous line
^, _	first character on current line (other than tab or space)
by screen
^F, ^B	scroll forward, backward one screen
^D, ^U	scroll forward, backward half screen
^E, ^Y	show one more line at bottom, top of screen
z<enter>	position line with cursor at top of screen
z.	position line with cursor at middle of screen
z-	position line with cursor at bottom of screen
marking position on screen
mz	mark current position with z
`z	move cursor to mark z
'z	move cursor to first non-whitespace character on line containing mark z
miscellaneous movement
fG	forward to character G
Fd	backward to character d
tg	forward to character before g
Tw	backward to character after w
w	beginning of next word
W	beginning of next WORD (punctuation is part of word)
b	back one word
B	back one WORD (punctuation is part of word)
e	end of word
E	end of WORD (punctuation is part of word)
), (	next, previous sentence
]], [[	next, previous section
}, {	next, previous paragraph ( this will depend on your settings for what constitutes a "section" and "paragraph" )

EDITING TEXT
inserting text
a	append after cursor
A	append at end of line (same as $a)
i	insert before cursor
I	insert at beginning of line (same as _i)
o	open line below cursor
O	open line above cursor
^[	terminate insert mode (escape)

Back to top
(Part I/c)

VI COMMAND KEYS IN ALPHABETICAL ORDER

( ^A stands for <control-A> ) If there is an X in the count column then the command can be preceded by a number and the command then is executed count times. If the command is an editing command such as a or i, then you'll have to hit escape for the execution to happen count times. See example in Part I/a.
A word consists of [a-zA-Z_] and a WORD consists of previous plus punctuation, basically delimited by whitespace.

Count	Command	Action
X	a	append after cursor
X	A	append at end of line (same as $a)
	^A	unused
X	b	back up one word
X	B	back up one WORD
X	^B	scroll up one screen
X	c	begin a change (combine with movement command)
X	C	change line from cursor to end of line (same as c$)
	^C	abort current ex command; in insert mode : end insert mode
X	d	begin a delete (combine with movement command)
X	D	delete from cursor to end of line (same as d$)
X	^D	scroll down a half screen; in insert mode : back up one shiftwidth
X	e	goto end of word
X	E	goto end of WORD
X	^E	show one more line at bottom of screen
X	f	forward to next typed character
X	F	backward to next typed character
X	^F	scroll down one screen
	g	unused
X	G	goto count line; default is end of file
	^G	print file info on status line (bottom of screen)
X	h	cursor left
X	H	goto top of screen; count will place you that many lines from top of screen
X	^H	cursor left; in insert mode : backspace
X	i	insert before cursor
X	I	insert at beginning of line (same as _i)
	^I	unused; in insert mode : tab key
X	j	cursor down
X	J	join two lines
X	^J	cursor down; in insert mode : same as enter
X	k	cursor up
	K	unused
	^K	unused
X	l	cursor right
X	L	goto bottom of screen; count will place you that many lines from bottom of screen
	^L	redraw screen, usually
	m	mark current cursor position with character typed (a-z)
	M	goto middle of screen
X	^M	goto first character on next line; in insert mode : same as enter key
	n	repeat last search command
	N	repeat last search command in reverse direction
X	^N	cursor down
X	o	open a new line below the cursor
X	O	open a new line above the cursor
	^O	unused
X	p	put yanked or deleted text after or below cursor
X	P	put yanked or deleted text before or above cursor
X	^P	cursor up
	q	unused
	Q	quit vi, invoke ex (not very useful) return with vi
	^Q	unused (some terminals, stop data flow)
X	r	change character under cursor to character typed
X	R	replace characters (overwrite mode)
	^R	redraw screen, usually
X	s	substitute characters under cursor to ones typed
X	S	substitute entire line
	^S	unused (on some terminals, resume data flow)
X	t	forward to before next character typed
X	T	backward to after next character typed
	^T	goto previous tag; in insert mode : move right one shiftwidth
	u	undo last change
	U	restore current line
X	^U	scroll screen up a half screen; in insert mode : delete back to start of insert (depends on terminal settings)
	v	unused
	V	unused
	^V	unused; in insert mode : quote next character
X	w	forward one word
X	W	forward one WORD
	^W	unused; in insert mode : back up to beginning of word (depends on terminal settings)
X	x	delete character under cursor
X	X	delete back one character
	^X	unused
X	y	begin a yank (combine with movement command)
X	Y	yank current line (same as yy) (map it to y$ to be consistent with D and C)
X	^Y	show one more line at top of screen
	z<enter>	reposition line with cursor to top of screen
	z.	reposition line with cursor to middle of screen
	z-	reposition line with cursor to bottom of screen
	ZZ	quit vi, write file if changes were made
	^Z	suspend vi on systems that have job control (depends on terminal settings)
	^@	unused
	^[	terminate insert mode (escape key)
	^	unused?
	^]	goto tag under cursor
	^^	edit alternate file
	^_	unused?
	^?	unused? delete key?
X	space	cursor right
	!	filter program through external filter, requires an object to work on (combine with movement command) (press enter to execute)
	"	use register for next delete, yank or put, registers are (a-zA-Z0-9)
	#	unused?
X	$	goto end of line
	%	goto matching bracket () [] {}
	&	repeat last substitute
	'	to first non-blank character on line with mark (a-z)
X	(	beginning of next sentence
X	)	beginning of current sentence (sentence is delimited by ., !, ? and followed by at least one space)
	*	unused?
X	+	down one line to first non-blank character (j_)
X	,	repeat f, F, t, T commands in reverse direction
X	-	up one line to first non-blank character (k_)
	.	repeat previous command
	/	search forward for text entered (repeat previous search if no argument supplied) (press enter to execute)
	0	goto beginning of line
	:	enter an ex command (press enter to execute)
X	;	repeat f, F, t, T commands
X	<	begin a shift left (combine with movement command)
	=	unused (unless in lisp mode in which case it formats to standard lisp formatting)
X	>	begin a shift right
	?	search backward for text entered (repeat previous search backward if no argument supplied) (press enter to execute)
	@	execute a register (0-9a-z".)
X	[[	beginning of current section (as delimited by the sect= option)
		unused
X	]]	beginning of next section (as delimited by the sect= option)
	^	goto first non-blank character on line
X	_	goto first non-blank character on line
	`	goto mark (a-z)
X	{	beginning of current paragraph (as delimited by a blank line or the para= option)
X	|	goto count column, default is beginning of line
X	}	beginning of next paragraph (as delimited by a blank line or the para= option)
X	~	change case of character under cursor

Most vi commands can be remapped. Here are some good ones.
map ^N :n^M
map ^P :rew^M
map Y y$
map ^K :q!^M
map g 1G
Control characters will have to be quoted with ^V, that is <control-V>

Back to top
(Part II/a)

EX EDITOR

ADDRESS SYMBOLS
0	beginning of file
$	end of file
1,$	all lines in file
%	stands for filename, hence it means the entire file (1,$)
#	stands for alternate file
x,y	lines x through y
x;y	lines x through y, current line reset to x
.	current line
n	absolute line number n
x-n	n lines before x
x+n	n lines after x
+[n]	n lines ahead (default is one)
-[n]	n lines back (default is one)
'x	line marked with x
''	previous mark (that's two single quotes)
/pattern/	forward to line matching pattern
?pattern?	backward to line matching pattern

Back to top
(Part II/b)

QUICK LIST OF EX COMMANDS AND THEIR ABBREVIATIONS

 | abbreviate  ab      | move        m      | tag               ta   | | append      a       | next        n      | unabbreviate      una  | | args        ar      | number      # nu   | undo              u    | | change      c       | open        o      | unmap             unm  | | chdir       cd chd  | preserve    pre    | version           ve   | | copy        t co    | print       p      | visual            vi   | | delete      d       | put         pu     | write             w    | | edit        e       | quit        q      | xit               x    | | file        f       | read        r      | yank              ya   | | global      g v     | recover     rec    | (window)          z    | | insert      i       | rewind      rew    | (escape to OS)    !    | | join        j       | set         se     | (lshift)          <    | | list        l       | shell       sh     | (rshift)          >    | | map                 | source      so     | (line number)     =    | | mark        k ma    | substitute  s & ~  | (execute buffer)  * @  | 

Back to top
(Part II/c)

EX COMMANDS

( anything in [] is optional , anything in {} is the rest of the name of the command which is also optional )
The default for address is the current line, except for g, g! , v, w; for these the default is the entire file.

ab{breviate} [word text]

    define string when typed to be translated into text.     if string and text not specified, list all abbreviations     abbreviations are usually put into your .exrc file     eg. :ab Xvi vi is the best editor         :ab charcater character         :ab teh the         :ab hvae have 

[address[,address]]a{ppend}[!]
text
.

    append text at address. ! switches autoindent. 

ar{gs}

    print filename arguments. 

cd [path]

    without path change to home directory, with path change to path 

[address[,address]]c{hange}[!]
text
.

    replace lines with text. ! switches autoindent. 

[address[,address]]co{py}destination

    copy lines from address to destination.     eg. :1,10co50      copy lines 1 to to 10 to below line 50 

[address[,address]]d{elete} [buffer][count]

    delete lines in address, if buffer is specified save lines to buffer.     count specifies the number of lines to delete starting with address.     eg. :/include/,/main/d      delete lines between include and main                                 including include and main         :/include/+,/main/-d    as above but not including include nor main         :3d     delete line 3         :d3     delete 3 lines starting with current         :.,$d a delete to end of file from current line into buffer a         :d a3   delete next three lines starting with current into buffer a 

e{dit}[!] [+n] [file]     begin editing file. ! will discard changes to current file.     n specifies line to begin editing file (default 1).     eg. :e file     edit file         :e #        edit previous file 

f{ile} [filename]

    change name of file to filename. without argument print current     filename.     eg. :f %.new    appends .new to current filename, renaming file to                     file.new 

[address[,address]]g{lobal}[!]/pattern/[commands]

    execute commands on lines that contain pattern, if address is specified     within the address range. ! execute on lines not containing pattern.     without commands print matching lines.     eg. :g/#include/d      delete all lines that have include directives         :g!/#define/p      print lines that are not define statements         :g/^/*/p          print lines that start with /*         :g/^[ ^I]*$/d       delete empty lines as well as lines with only tabs                             or spaces         :g/strcmp/d5        delete lines that have strcmp in them as well                             as the following 4 lines 

[address[,address]]i{nsert}[!]
text
.

    insert text at line before address. ! switches autoindent. 

[address[,address]]j{oin}[!][count]

    join lines in specified range. ! preserves white space.      eg. :1,5j!     join lines 1 to 5, preserve white space 

[address[,address]]k char

    synonymn for mark, character can follow k with no intervening space. 

[address[,address]]l{ist}[count]

    print lines so that tabs show as ^I and end of lines are marked with $. 

map[!] [char commands]

    define a keyboard macro for named char that is a synonymn for commands.     !  will create a mapping for input mode. with no arguments print mapped     keys.     eg. :map ^N :n^M    (to get a control character type ^V followed by the                         control character) 

[address[,address]]ma{rk} char

    mark lines with char. char is a single lowercase letter.     eg. :ma z   mark line with z         :'z     return to line with mark z 

[address[,address]]m{ove} destination

    move lines specified by address to destination.     eg. :.,/include/m /string/  move lines from current to include line below                                 line with string 

n{ext}[!] [[+commands] filelist]

    edit next file from argument list. if filelist is provided, replace     argument list with filelist. ! will discard changes to current file. 

[address[,address]]nu{umber}[count]

    print lines specified by address, precede each line by its line number.     count specifies the number of lines to print. 

[address[,address]]o{pen}[/pattern/]

    enter vi's open mode with lines specified by address, or at lines     containing pattern. 

pre{serve}

    save current buffer as if the system had crashed 

[address[,address]]p{rint}[count]

    print lines specified by address. count is the number of lines to print.     eg. :304;+5p    print five lines starting with 100, reset current line to                     100 

[address[,address]]pu{t} [buffer]

    restore lines that were previously deleted or yanked and put them after     current line. put line from buffer if specified. 

q{uit}[!]

    quit. ! discard changes to file. 

[address[,address]]r{ead} file

    copy text from file on line below specified by address.     eg. :0r data    read in file "data" at top of file 

[address[,address]]r{ead} !command

    read the output of command into file after line specified by address.     eg. :$r !ls -aFC    run "ls" and read in its output at end of file 

rec{over} [file]

    recover file from system save area. 

rew{ind}[!]

    rewind argument list to first argument. ! discards changes to current     file. 

se{t} parm1 parm2

    set value to an option with each parm. if no parm is supplied print all     changed options. for boolean options parm is phrased as option or     nooption, other options are option=value. all will print all available     options.     set commands are usually put into your .exrc     eg. :se autowrite tabstop=4 autoindent shiftwidth=4 wrapmargin=5         :se all     print all available options 

sh{ell}

    create a new shell. resume editing when shell exits. 

so{urce} file

    read and execute ex commands from file     eg. so ~/old.exrc 

[address[,address]]s{ubstitute}[/pattern/replacement/][options][count]

    replace pattern with replacement. if pattern and replacement are omitted     repeat last substitution. count specifies the number of lines on which to     substitute starting with address.     options     c   prompt for confirmation     g   substitute all instances on line     p   print last line on which substitution was made     eg. :%s/[hH]ello/Hi/g       replace hello or Hello with hi, all ocurrences         :.,$s/[uU][nN][iI][xX]/U&/10   upcase unix on next 10 lines         :%s/<./u&/g    turn the first letter of all words to uppercase         :1,/main/s/int/long/g   substitute occurances of int before main with                                 long 

[address[,address]]t destination

    synonymn for copy 

ta{g} tag

    switch to file containing tag.     eg. :!ctags *.c     run ctags on all .c files in directory         :ta func        switch to file containing func, put cursor on it 

una{bbreviate} word

    remove word from list of abbreviations. 

u{ndo}

    undo changes made by last editing command. 

unm{ap}[!] char

    remove char from keyboard macros. ! remove macros for input mode. 

[address[,address]]v/pattern/[commands]

    synonymn for global!     eg. :v/./,/./-j     join empty lines to have only single empty line                         between lines of text 

ve{rsion}

    version of editor. 

[address[,address]]vi [type][count]

    enter visual mode at line specified by address. exit with Q. count     specifies initial window size.     -   place line at bottom of window     .   place line in center of window     ^   print previous window 

vi [+n] file

    begin editing file in visual mode at line n. 

[address[,address]]w{rite}[!] [[>>] file]

    write lines specified by address to file. >> is used to append to file.     with no address write all of the file. ! forces the write.     eg. :1,25w new_file     write lines 1 to 25 to "new_file"         :50,$w >> new_file  append line 50 to end of file to new_file 

[address[,address]]w !command

    write lines specified by address to command. 

wq[!]

    write lines specified by address to file and quit. ! forces the write 

x{it}

    exit file. save changes. 

[address[,address]]ya{nk} [buffer][count]

    place lines specified by address in buffer char. count is the number of     lines to yank starting with address.     eg. :20,100ya z     yank lines 20 to 100 into buffer z 

[address[,address]]z[type][count]

    print a window of text. count is the number of lines to display starting     with address.     type     +   place line at top of window(default)     -   place line at bottom of window     .   place line in center of window     ^   print previous window     =   place line in center of window. leave line as current line. 

[address[,address]]![command]

    execute command. if address is specified apply lines from address as input     to command, and replace lines with output.     eg. :!ls -aFC           run ls, will not read output into file         :0!ls -aFC          run ls, read in its output to beginning of file         :11,35!sort -fd     sort lines from 11 to 35         :%!spell -b         run the spellchecker on entire file 

[address[,address]]=

    print line number of matching address. with no address print line number     of last line. 

[address[,address]]<[count]
[address[,address]]>[count]

    shitft lines left(<) or right(>). count specifies the number of lines to     shift starting with address.     eg. :1,9>   indent lines 1 through 9 one shiftwidth 

address

    print line specified by address. 

return

    print next line. 

[address[,address]]&[options][count]

    repeat previous substitution. count specifies the number of lines to     substitute on starting with address.     eg. :s/msdos/UNIX   substitute msdos with UNIX         :g/OS/&         redo substitutions on all lines with "OS" 

[address[,address]]~[count]

    replace previous regular expression with the previous replacement from     substitute. 

*[buffer]
@[buffer]

    execute named buffer 

[address[,address]]#[count]

    synonym for number 

The following can be used as addresses in ex, as well as in commands :g, :s, :v, and in the vi commands ?, and /

Back to top
(Part III)

REGULAR EXPRESSION SEARCH AND SUBSTITUTE

SPECIAL CHARACTERS
.	match any single character except newline
*	match any number (including none) of the single atom immediately preceding
^	match beginning of line if at start of expression
$	match end of line if at end of expression
[]	match anything enclosed in [], called a character class
[^]	match anything not enclosed in []
( )	store pattern for later replay
<	match following characters at beginning of word
>	match preceding characters at end of word
	escape character following (needed for eg. . to match a .)
n	reuse previous pattern, n is a number between 1 and 9 eg. 1
&	reuse previous search pattern
~	reuse previous replacement pattern
u	change character to upper case
U	change characters to upper case
l	change character to lower case
L	change characters to lower case
e	turn off previous u or l
E	turn off previous U or L

EXAMPLES
Perl	matches Perl
^Perl	matches Perl at beginning of line
Perl$	matches Perl at end of line
^Perl$	matches Perl as the only word on line
^$	matches the empty line
^..*$	matches a line with at least one character
.*	matches any string of characters including none
^[ ^I]*$	as above but line can also contain spaces and/or tabs(^I)
[pP]erl	matches perl or Perl
[aA][nN]	matches an, aN, An, AN
p[aeiou]g	second letter is a vowel
i[^aeiou]g	second letter is not a vowel
p.g	second letter is anything
^....$	matches a line with exactly four characters
^.	matches any line beginning with a dot
^.[0-9a-z]	same with a lowercase letter or digit following
^[^.]	matches any line that does not begin with a dot
;$	matches a line ending with a semicolon
figs*	matches fig, figs, figss, figsss etc.
[a-z][a-z]*	matches one or more lowercase letters
[a-zA-Z]	matches any character
[^0-9a-zA-Z]	matches any symbol (not a letter or number)
<the	matches the, theater, then
the>	matches the, breathe
<the>	matches the
:%s/<./u&/g	turn the first letter of all words to uppercase
:%s/<[a-z][!-~]*>/u&/g	as above
:%s/<[a-z]/u&/g	as above
:%s/.*/L&/	turn entire file to lowercase
:%s/<[^>]*>//g	remove strings from file that start with a less than sign and end with a greater than sign (html tags)
., ^, &, $ must be preceded by a to make literal when magic is on. * must be preceded by a under certain circumstances although it never hurts to precede it with a backslash whenever you mean a * not its regexp meaning. % and # should also be escaped as they mean current and alternate file to ex. Regular expressions only work in a s/pattern/replacement/ for the pattern and not the replacement, for obvious reasons.