Nifty Vim Tricks

Two weeks ago I explained to you why I use vim. Last week, I taught you how to configure it. This week I want to talk about something different: power user stuff.

Let’s talk useful vim tricks. Everyone amasses an arsenal of these over the years. Some are really, really useful – other ones merely convenient. I wanted to share some of mine, in hopes that you will show me yours. Below I’m concentrating on basic, core vim functionality. I could extend this list quite a bit by including plugins, but not everyone uses them. That can be a topic for whole other post.

Stroke those keys like a Pro!

First let’s look at some interesting key combos. I will give them to you along with easy to remember mnemonics. Remember, it really pays to think of vim commands as words that can be strung together into sentences.

There are dozens more like that. These are just useful examples, and you can easily mix and match various commands and motions to make new actions based on the above. Foe example: d a t, y a < and etc…

Two very useful motions are g g (which takes you to the begging of the file) and G which skips to the end. Whatever command you stick between these two will affect the entire file. Here are some examples:

One of the common problems when working with vim is that the yank commands do not actually use the system clipboard. When vim was created, clipboard was not a thing yet, so Billy Joy built vim around the idea of registers. When you yank, vim puts the contents into named registers. You can specify which one you want when you yank. The modern versions of vim use the + register to mean system clipboard. So you can easily copy and paste between applications, or different instances of vim like this:

In the last command I used the % key. Whenever you use it in command mode, it essentially means “this entire file”. So the above command is basically a slightly more succinct equivalent of g g " + y. Note that this key becomes even more useful when combined with the ! key which escapes to the shell.

Note that you can use the ! command to run any external application as long as it is in your system path:

Here are some other nifty tricks that deal with opening, saving and undoing changes in your files:

Mappings for Mupets

Let’s talk about some mappings. Here are some of the things I always remap in my .vimrc and you should too:

I mentioned this mapping before, but I think it bears repeating. It lets’ you press ; to issue commands in normal mode. It overrides repetition of t and f commands but how often do you use that feature versus vim command mode? I personally think that the key strokes you save by not having to hold shift are worth it.

nnoremap ; :

This mapping allows you to use j and k to move by screen lines, not by real lines – great for when you have soft word wrap enabled.

nnoremap j gj
nnoremap k gk

" also in visual mode
vnoremap j gj
vnoremap k gk

This will run ctags on current directory recursively when you press F6. I mentioned ctags in my previous vim post, so you should be familiar with it already.

nnoremap  :!ctags -R

Another trick I already mentioned in the other post, included here for the sake of completeness: pressing \ space clears the search highlights

nmap   :nohlsearch

Use \ Enter to break a line at the cursor:

nmap   i

This is a new one – sometimes you may want to insert blank lines in your text without entering insert mode. Now you can do it with \ o and \ O.

nmap  o o
nmap  O O

Use jj to quickly escape to normal mode while typing:

inoremap jj 

Toggle paste mode to paste properly indented text. It gives you a visual cue in the status line:

nnoremap  :set invpaste paste?
set pastetoggle=
set showmode

If you happen to work with PHP a lot (I do obscene amounts of PHP at work) this is kinda useful:

" run current PHP file through php 
:autocmd FileType php noremap p :w!:!php %
" run current PHP file through php linter (syntax check) check
:autocmd FileType php noremap l :!php -l %

This one is quite useful: toggle between absolute line numbers and relative line numbers. The relative numbering is really useful. For example, lets say you want to jump to a specific line in the code – with relative numbers you can just glance at the line number and know you need to use 1 0 j to get there. With absolute line numbers you would have to either guess, do some quick arithmetic in your head or just start to repeatedly hit j till you get there. That said, absolute line numbers are useful for debugging. So this trick gives you best of both worlds:

function! g:ToggleNuMode()
	if(&rnu == 1)
		set nu
	else
		set rnu
	endif
endfunc

nnoremap  :call g:ToggleNuMode()

Now you can hit F5 to toggle between the two modes.

Here is something very useful when you don’t want to listen to my advice and remap ; to :. Very often you will be typing fast, and you will hold Shift a fraction of a second too long typing in : W instead of : w and fail to save. Here is a solution:

command W w
command WQ wq
command Wq wq
command Q q

You simply remap common typos to the correct, intended commands. Now even if you fuck up, you will probably trigger the command you wanted.

Finally, here is a trick that makes copying and pasting between windows and applications a little less of a pain in the ass:

noremap y "+y
noremap Y "+Y
noremap p "+p

Now when you want to copy current line to system clipboard you simply hit \ y y or \ Y. It saves you two extra keystrokes either way.

Other Stuff

Final really quick trick that most people don’t know about. Sometimes you want to open your vim in a “clean” state. By that I mean no plugins, no custom key bindings, no advanced settings. Factory default vim if you will. Here is how you do it:

vim -u NONE

How much is too much?

A lot of people like to brag about their minimalistic .vimrc and how they are supposedly using vim “the right way”. Those people are what we call “willfully inefficient”. The entire point of using an editor like Vim or Emacs is their customizability. If you are not using it, then you are likely spinning wheels and using extra keystrokes which you could have bound to a single key. Hack your vim with reckless abandon, I say. Put your .vim folder under source control and you will never have to go without it as long as you have internet access.

This is about it for me. I hope this was somewhat useful and or enlightening for you guys. What are your favorite tips and tricks? Please post them in the comments.