vim is not an editor with killerfeatures included,
but a killerfeature with an included editor.

Using modelines, you can define per file settings inside the file itself.
Cause modelines are disabled per default, they have to be activated first:

set modeline

The variable modelines defines how many lines from top (or bottom, respectively) of the file are expected to contain a modeline:

set modelines=5

You can define modelines via two ways, although the old scool method is a little more compatible: 1. new school:

         [text]{white}{vi:|vim:|ex:}[white]{options}
 
 [text]          any text or empty
 {white}         at least one blank character (<Space> or <Tab>)
 {vi:|vim:|ex:}  the string "vi:", "vim:" or "ex:"
 [white]         optional white space
 {options}       a list of option settings, separated with white space or ':',
                 where each part between ':' is the argument for a ":set"
                 command
 
 Example: >
    vi:noai:sw=3 ts=6

2. old school:

         [text]{white}{vi:|vim:|ex:}[white]se[t] {options}:[text]
 
 [text]          any text or empty
 {white}         at least one blank character (<Space> or <Tab>)
 {vi:|vim:|ex:}  the string "vi:", "vim:" or "ex:"
 [white]         optional white space
 se[t]           the string "set " or "se " (note the space)
 {options}       a list of options, separated with white space, which is the
                 argument for a ":set" command
 :               a colon
 [text]          any text or empty
 
 Example: >
    /* vim: set ai tw=75: */

Using this line in the .vimrc file, the cursor is placed at the last known position in the file when opening:

:au BufReadPost * if line("'\"") > 0 && line("'\"") <= line("$") | exe "normal g'\"" | endif

Mappings are a useful utility to define command aliases and little macros inside vim.

    commands:                                 modes: ~
                                          Normal     Visual  Operator-pending ~
:map   :noremap   :unmap   :mapclear        yes        yes        yes
:nmap  :nnoremap  :nunmap  :nmapclear       yes         -          -
:vmap  :vnoremap  :vunmap  :vmapclear        -         yes         -
:omap  :onoremap  :ounmap  :omapclear        -          -         yes

                                          Insert  Command-line  Lang-Arg ~
:map!  :noremap!  :unmap!  :mapclear!       yes        yes         -
:imap  :inoremap  :iunmap  :imapclear       yes         -          -
:cmap  :cnoremap  :cunmap  :cmapclear        -         yes         -
:lmap  :lnoremap  :lunmap  :lmapclear       yes*       yes*       yes*

_{Excerpt from vim help context *map-modes*}

The vim help context contains a list of codes for special keys:

:help keycodes

Defining a mapping is as simple as:

:imap try try {<Enter>} catch(Exception e) {<Enter><Enter>}<Esc>3ko

The effect can be tested in insert mode, typing try.

Removal of the mapping defined above is done via:

:iunmap try

Especially when debugging code, cTags are a wonderful tool when it comes to manually tracing through the code flow. Creation of the tags-file is often as simply as issuing a

make tags

or

ctags -R .

after that, one can jump to the definition of a code element by hitting ^5 or ^[. When the destination is not the expected one, it's helpful to check alternative targets using :ts, then selecting an entry by entering the corresponding number. Jump back using ^t.

The script ctags.vim helps combining the power of cTags and vim. After downloading it has to be placed inside one's plugin dir (e.g. ~/.vim/plugin).

For a quick start, the following two ex-commands have to be given to enable the script's functionality:

:let g:ctags_statusline=1
:CTAGS

when everything was done right, the name of the function the cursor is currently positioned at is printed in the status bar.

On my notebook, I've setup ctags.vim like so:

• save the script as ~/.vim/plugin/ctags.vim
• create or edit the file ~/.vim/ftplugin/c.vim:

let g:ctags_statusline=1
CTAGS

Now upon opening a file with suffix .c, the plugin is automatically being loaded and activated (leads to an error if no tags file was found, but nothing fatal or disturbing).

Especially tabs and spaces are characters that can't be distinguished without further help from vim. As this is often necessary (e.g. for a clean C Coding Style), help is near:

Insert the following into your .vimrc to make the set list command output more useful stuff:

" Show tabs, trailing spaces, long lines
"set list listchars=tab:>_,trail:_,extends:+ " ,eol:$
" disable it by default
set listchars=tab:>_,trail:_,extends:+ " ,eol:$

The code below adds some more invasive displaying. Not only because it's enabled by default, but also because of the nice red colour.

" show trailing spaces and spaces before tabs (this is better)
hi link localWhitespaceError Error

" match trailing spaces (being displayed right from the start)
"au Syntax * syn match localWhitespaceError /\s\+$/ display
" match trailing spaces, but not as soon as they are being typed
" au Syntax * syn match localWhitespaceError /\(\zs\%#\|\s\)\+$/ display
" same as above, but allow highlighting inside other syntax groups (comments for instance)
au Syntax * syn match localWhitespaceError /\(\zs\%#\|\s\)\+$/ display containedin=ALL

" show space before tab
au Syntax * syn match localWhitespaceError / \+\ze\t/ display containedin=ALL

Having skeletons (templates) when creating certain types of files is quite easy thanks to vim's powerful scripting language:

au BufNewFile <pattern> 0r <path_to_skeleton>

For instance, having a skeleton for tex letters at ~/.vim/skel/letter.tex:

au BufNewFile *.letter.tex 0r ~/.vim/skel/letter.tex

will insert the skeleton's content into every new file with name matching “*.letter.tex”.

• Graphical Cheat Sheet and tutorial
• ctags.vim script
• Accessing the System Clipboard
• Search Patterns
• surround.vim script