I particularly enjoy the Change In/Around commands: ci" replaces the inside of whatever double-quoted text block you are in, ca' replaces the single-quoted text block including the quote characters, and there are variants for various brackets, braces, parens, and paragraphs!

g+, g- (mic drop)

No, in all seriousness, the documentation sucks on this… So I’ll explain it how it was explained to me by a colleague:

Vim stores edit history and undo as a tree. For example, if you do A, B, C, D, undo, undo, E, F, undo, undo, undo, G, vim will store this history:

                 D        F
                 |        |      G
                 C        E      |
                 |        |      |
                 +----+---+      |
                      |          |
                      B          |
                      |          |
                      +----+-----+
                           |
                           A

g+ and g- will navigate between the “tips” of this tree, so between D, F and G. One goes back, the other forward. I never know which one is which between g+ and g- to go the way I want, so I always try both until I realize it’s going the right way :) .

gq to format selected paragraphs.

Macros. They’re great because you don’t have to know fancy vim stuff to use them. You record a sequence of ordinary edit commands and play back the sequence. For example, to add quotes around a line, and then add quotes around the next 50 lines:

qqI"<ESC>A"<ESC>jq
50@q

q starts recording the macro to the named register (I just use q as the register for expediency). The rest of the sequence adds the quotes, moves 1 line down, and ends the recording with a final q. Then run the recorded macro (@q) 50 times. Moving down one line at the end puts the cursor in the right spot for the next macro run, so you can repeat the macro like this. You do need to be careful about what motions you use, e.g. using f/F to move to an exact delimiter rather than using h/l a fixed amount of times, but it’s usually easy to manage.

You could also do this with :norm, but I didn’t want to type out an elaborate multi-line example that :norm would struggle with on my phone. The equivalent :norm, starting with a visual select:

V50j:norm I"<C-v><ESC>A"

Notice the <C-v> before <ESC>, necessary to insert a literal escape key into the command sequence. Also useful for inserting literal newlines in substitutions and the like.

<C-o and <C-i> to navigate the jumplist. https://medium.com/@kadek/understanding-vims-jump-list-7e1bfc72cdf0

marks https://vim.fandom.com/wiki/Using_marks

It’s not native but I find fzf to be indispensible: https://github.com/junegunn/fzf.vim

Your example of shelling out with :read is good, but you can do more with the ! operator. In particular, note that it works in immediate mode and has the same flexibility as the yank/delete/change commands. So dd deletes a line and !! prompts you for a command to run, passes the current line to that command on stdin and pastes the stdout where the line was, so I use !!ls for your use case (if I don’t care about the current line I am on).

All these commands take a ‘movement suffix’. So dG deletes from where you are to the end of file and !G allows you to run a command on the rest of the file. This works with any movement command…. [*]

This allows things like !Gsort to sort your file - basically you’ve got the unix pipeline + text handling toolset in your editor.

I sometimes want to eyeball two files to see differences. I typically have :map q :e#^M so tapping ‘q’ switches me to the other file and another tap brings me back.

With the :<range>s command, you can specify ^ or $ to add text at beginning or end of line. The range can be % for the whole file, or you can specify <from>,<to>. From and to can be line numbers, or . for current file or even a search, so :.,/foo/s/x/y/ means “search and replace x for y in the lines from here to the next occurrence of ‘foo’”.

e.g. :%s/^/func /to add afunc ` prefix to every line of the file

Lastly, knowing that . repeats the last edit is very useful and helps make you careful about what is in the edit so you can usefully re-use it. (I also get a lot out of simple macros written with the map command. I typically use ‘,’ for a throwaway temp macro key, so: :map , Ifunc ^VESCA() {^VESCj does “prepend ‘func’, append ‘() {’ and move to next line.) (The ^VESC there is “type a literal control-V then hit the ESC key”, this allows you to embed an “escape to leave insert mode” in your macro).

[*] the movement suffix is super useful if you don’t already know it. You can suffix d, y, !, c etc (are there others?) with any vi movement command and it will apply the command to the region between the cursor and where the movement takes you. e.g:

• dk deletes current and next line.
• df. deletes from where you are on the current line up to and including the next . char.
• d/foo^M deletes from where you are to the next occurence of foo.
• c3W is “change three words”

gf to navigate to the file under the cursor. Is very flexible in it’s configuration, and can be set per filetype. I find it really useful to navigate to includes.

I really like having a custom dictionary I can append all my tech jargon into using zg command when spellcheck is enabled: set spell. My .vimrc leverages the following (I wish I could recall where I originally got this technique from):

set spellfile=~/.vim/spell/tech.utf-8.add

" Rebuild spell only if .spl is missing
function! RebuildSpell()
  for d in glob('~/.vim/spell/*.add', 1, 1)
    if filereadable(d) && (!filereadable(d . '.spl') || getftime(d) > getftime(d . '.spl'))
      silent exec 'mkspell! ' . fnameescape(d)
    endif
  endfor
endfunction

call RebuildSpell()

I don’t use Vim a lot these days but several years ago, when I was an avid Vim user, one of my favourite Vim features was the blockwise-visual mode that can be started with the Vim key sequence ctrl-v. It is very nifty for making rectangular selections and move around columns of text.

I use Emacs these days which offers a very similar functionality in the form of rectangular-mark-mode that can started with the Emacs key sequence C-x SPC.

I discovered the following quite late:

q:

opens a buffer with the history of last used commands. You can navigate then inside, as if it is text, i.e. you can even search. It is especially helpful when you need to repeat a command, but slightly different - in this case you go to the line with the command that you want to change, change it and press , it’s not even necessary to press first, just press enter.

q/

Like above, but for the search history.

set history=10000

I put this in $HOME/.vimrc to keep in history more than usual, for the above operations.

g8

Show the Unicode code point for a character (file must be in a Unicode encoding, for example utf-8).

Entering a Unicode character:

1. Go into insert mode, i.e. with i,I,a,A,o,O
2. Press CTRL V
3. Insert ‘u’, i.e. a small u character
4. Now enter the unicode code point as a hexadecimal number

xp

Swap 2 consecutive characters (helpful for typos)

Filtering (piping) the buffer through a unix command (for example, to re-format and re-indent ugly XML):

:%!xmllint --format -

The above will take all the text in in the current buffer (the ‘%’ in the command), start the xmllint command (the ‘!’ in the command above) and feed the text into standard input to the xmllint command, and whatever xmllint outputs will be put in the buffer.

Using . to repeat the last command in normal mode.

My favorite way to use this is to find and replace words in a file. Search for the word with /. Then cw or ciw (change word or change in word). Press n to find the next instance of the word, and just press .. Repeat this for every word in the file.

Mine is moving ctrl to my capslock key, and then becoming proficient with the various c- prefixed keys like <c-w> for window navigation and <c-p> or <c-x><c-f> and others for completion.

A similar thread: https://lobste.rs/s/6qp0vo/at_least_one_vim_trick_you_might_not_know

Related to the OP’s favourite — batch renaming!

:r !ls /foo/bar-*/*.txt

:%s/.*/mv “&” “&”/

Now use vim to manipulate dest path

:w !sh

I’ve been using GVim since 2007, but still kinda an intermediate level user. I don’t have a pressing need to dive deeper. I prefer using mouse, arrow keys, tab pages, etc and I don’t use any packages.

It is difficult to identify a particular trick to share:

• Ctrl+x Ctrl+l to auto complete a line in Insert mode (I use it a lot, so I’ve mapped it to Ctrl+l)
• You can use <count>g followed by Ctrl+a in Visual mode to increment numbers as an arithmetic progression
• gn searches the last used pattern in the forward direction and visually selects the matched portion, especially useful when you combine it with cgn (which you can then repeat with . command)
• :terminal if you want a terminal session as a horizontal split window within Vim (use :vertical :terminal if you want vertical split)

I have a list of Vim resources here: https://learnbyexample.github.io/curated_resources/vim.html

I interact with a lot of encoded formats like JSON Web Tokens (JWTs) as well as wanting to unpack URLs, so I’ve found it super handy to be able to pipe visually selected text into a command, i.e.:

:'<,'>!unpack

(source)

Or to do the same with a visual selection:

c<C-R>=system('unpack', @")<CR><ESC>

(source)

g commands when using it from the colon mode (command mode? i’m not sure what that’s called) same way as you’d do a find and replace in a file

something like %g/^ *$/d will delete the empty lines in a file or %g/WARN/d would delete warning lines in a log

useful for deleting all the lines that you don’t want to deal with in a log file or you can also perform other operations with it by replacing d.

Given that you’ve mentioned a basic vi(1) command as your favourite, I’m going to do the same:

 .

It’s a repeat the last command, at least in nvi :^)

In terms of :r!... I use it daily, i.e.:

 :r!ssh hostname 'cd /path/to/dir;cvs diff path/to/file'

So many…

https://github.com/junegunn/vim-easy-align is amazing for scratching that “my markdown tables all look like crap in source” itch

:%!python -mjson.tool for trying to make sense of payloads in log messages

https://github.com/preservim/nerdtree with indicators and webdevicons https://i.imgur.com/0gSouzm.png

Recording macros to mangle text when I’m too lazy to write code to do it…

this isn’t a command but check out goyo and limelight, which pair nicely when trying to emulate a distrationless writing tool like iA writer.

Relative line numbers are nice. Instead of eyeballing how many lines you’re looking at, you can just look to see the exact number of lines you want to move or affect with whatever command you want to use.

I typically have both number and relativenumber enabled, which shows the absolute line number for the current line, and relative line numbers for the rest.

I use this one constantly:

nnoremap <silent> <Leader>pi p`[v`]=

It copies text you have (previously) copied at the right level of indentation. (p does the copying, then `[v`]= visually selects and realigns whatever you just copied. I map it as pi (for put and indent), but you can make that whatever you prefer.)

The lack of auto-completion in the command line can be annoying but a quick <c-f> will move everything typed so far over to the command-line window(q:) where it is available.

I recently found out about set foldmethod=syntax and:

• zM: reset fold level (by default, collapse everything)
• zm: fold more things
• zr: fold less things

It is useful for reading long source code files.

:w !pbcopy

And its wl-copy and xclip relatives. This copies the file, or the selected part if in visual mode to the clipboard.

There are options to support this natively, but I usually opt for this rather than worrying about that specific flag.

Late to the party, but very useful and not yet mentioned is :cq, which exits vim without saving and with exit status 1. Can be used to abort many things, e.g. git commit or mail composition in mutt.

I enjoy using :cdo https://vimhelp.org/quickfix.txt.html#%3Acdo

set shm+=I to turn off the intro screen

syntax off to turn off syntax highlighting

set compatible to turn off yet more superfluities

then it’s almost like nvi (RIP) except you have to press ^R after u for multiple undo instead of .

:)