Reload All Buffers in Vim

In vim :e edits the current file (reloads from disk), which is useful if the file has been changed outside of vim and you want to load those changes into your buffer in vim.

I ran into a scenario where I ran a formatter outside of vim, and wanted to reload all files open in buffers in my vim session. I took a guess that :ea would edit all (like :wa writes all, :qa quits all) - but alas, swing and a miss.

The way to do this is with :bufdo e. bufdo executes the command - in this case e - in each buffer in the buffer list.

Vim Stores the Current Buffer's Path in a Register

Registers in (n)vim contain a lot of super useful data. To wit, the % register stores the path of the current buffer. Some useful things we can do with this register:

• Write the path of the current buffer into the file in Insert Mode: Ctrl + R, %
• If in Normal Mode: "%p
• Copy the path to the clipboard: run the command "let @+=@% (copy the % buffer into the + buffer, which is usually used by the system clipboard), or echo it

Sorting and Sort Order In Netrw (vim)

I sometimes press the r key on accident when in netrw. This toggles the sort direction of the files and folders. You can hit it one more time to change it back to default.

You can also try sorting by different parameters with the s key - name, file type, or file size.

View Highlight Groups in vim

Today I learned you can view all the highlight groups currently set in (neo)vim by running :highlight. With that you can see what the syntax highlighting looks like and how it's defined in terms of color codes or links to another group.

Turn Off Spell Check in Vim

When I'm writing longer form text in vim, I like to turn on spell check. I don't always want spell check on, so I toggle it on manually when I'm in a Markdown or text file: :set spell.

While I always remember how to toggle it on, I never remember how to toggle it off:

:set nospell

It's the same syntax for any setting - if you wanted to turn off incsearch, its :set noincsearch.

Delete the inner content of an HTML tag

After yesterday's TIL, fellow Hashrocketeer Jack Rosa shared with me a few other cool ways to delete things in vim.

My favorite way that he showed me that I never knew existed was using dit.

This deletes all content of the HTML tag you are inside of.

Let's use the following HTML for a couple examples:

1 |<div>
2 |  <h1>Header</h1>
3 |
4 |  <p>
5 |    This is some paragraph text that is <em>emphasized</em> for importance.
6 |  </p>
7 |</div>

If your cursor was anywhere within the <div></div> without being inside of a nested element, the result would be:

1 |<div></div>

If your cursor was anywhere within <em>emphasized</em>, the result would be:

1 |<div>
2 |  <h1>Header</h1>
3 |
4 |  <p>
5 |    This is some paragraph text that is <em></em> for importance.
6 |  </p>
7 |</div>

Conclusion: This is a nice and easy way to clear out html tags quickly.

Delete the whole "word" that you are inside

If you want to delete the entire word that your cursor is sitting in, you can press diw.

This deletes the word that you are inside of.

If you use a big W this will delete all the way in either direction until it hits whitespace, rather than just the end of the "word".

Go to the next/prev occurrence of a word in Vim

In Vim, if your cursor is over a word and you want to go to the next occurrence of that word in the file, just press *.

If you want to go to previous occurrence of the word, just press #.

Deleting Lines Without Copying to Default Register

When deleting a line in Vim using dd, if you wish to delete the line(s) without copying them to your default register, you can utilize "_dd

This command effectively deletes and copies them to a 'Black Hole' register, preserving the contents of your default register.

View Git Commits from Blame With Fugitive

I use vim-fugitive all the time to run a blame on the file I have open in (neo)vim. In the blame buffer, I typically hit enter on a commit to view the full commit in the buffer. It's nice, but then I need to jump back to view the code again.

Today I learned if you hit o instead of enter, the commit will open in a split below, which is much more convenient for me - it allows me to see the current version of the file, the blame, and the commit in one view. Game changer.

End of Line Substitutions in Vim

Today I learned a couple of nice regexes for substitutions in (n)vim.

Say you have a list, and you want to replace the character at the end of each line with something else:

123@
456@
789!

To replace the @s and ! with commas (,), you can use this substitute command :%s/.$/,/

123,
456,
789,

The regex .$ matches the character (.) that's at the end of the line ($)

Additionally, if you want to add something to the end of each line (but not replace), you can use the substitution :%s/$/,/ to transform

123
456
789

into

123,
456,
789,

Join lines in Vim

In Vim if you want to join two neighboring lines, place your cursor anywhere on the top line in NORMAL mode and press J / (SHIFT + j)

const object = {
  name:         <- With your cursor anywhere on this line 
  "bob"
}

=>

const object = {
  name: "bob"
}

h/t Matt Polito

Toggling Case with vim

~ in Vim toggles the case of the character under the cursor and then moves the cursor to the next character.

Execute (n)vim Commands on Startup

Today I Learned you can have (n)vim execute a command on startup.

For example - I often open vim and immediately run :Git to open vim-fugitive so I can easily navigate my modified and staged files. But that's 2 steps - 1 more than I want.

To achieve this, I can run nvim -c ":Git", where the -c is the command you want to execute on startup. For even fewer keystrokes you could create an alias!

Incrementing/Decrementing Numbers in Vim

You can use Ctrl+a to jump to the next number and increment. To jump to the next number and decrement, use Ctrl+x.

Note:

Jumping to the next number only works on your current line.

Save without Formatting in Vim

Or, more generally, to save without running auto commands: :noa w.

Check here to save without formatting in VSCode.

Jumping to matches

If you ever need to jump to a matching opening or closing parenthesis, square bracket or curly brace you can simply enter % from NORMAL mode to jump to the match.

Change between Horizontal & Vertical Splits (VIM)

If you have a vim buffers arranged using split or vsplit, you can change between orientations with the following key bindings:

• Ctrl+w k - will change a vsplit to a normal split split
• Ctrl+w h - will change a split to a vsplit

Returning to normal mode

When my keyboard randomly lost functionality of the ESC key, I was left unable to escape out of insert mode, back into normal mode.

If you ever find yourself in this conundrum, you can use CTRL-C to escape back to normal mode.

The caveat to this is that CTRL-C does not trigger abbreviations or the InsertLeave event.

Alternate ways to quit out of Vim

In an effort to increase my Vim knowledge, I stumbled across a blog post by rocketeer alumnus Josh Branchaud. His post covers a few ways to quit out of vim and it is worth the read.

In there I found these two useful ways for quitting out of Vim from Normal mode, as opposed to Command mode.

ZZ in normal mode is equivalent to :x   in command mode.
ZQ in normal mode is equivalent to :q! in command mode

Get the path to the current buffer in VIM

In VIM, you can get the path to the current buffer with the keybinding Ctrl+g. This will print that path to your statusline.

You can also get the path by using the % register:

:echo @%

Super helpful if you need to quickly copy/pasta that path for a coworker

https://www.tutorialspoint.com/vim/vim_registers.htm

Get the Current FileType in NVIM

If you've ever needed to debug a plugin, this might come in handy to get the current filetype. In my case, the filetype was not what I had assumed.

:set ft?
" or
:set filetype?

If you're curious to learn more, you can use :help ft to check out the docs on filetype

How to yank to system paste from Vim

"*y Which I have now mapped to <leader>y.

Couple this with outputting your scrollback buffer into Vim with Kitty for extra fun!

Enable vim mode in Xcode 13

From the global top menu choose Editor > Vim Mode

How to restrict visually selected replace

Make a visual selection in vim, then type :. You can do a search and replace by the normal means:

:'<,'>s/something/something else/g

The only problem with this is that it defaults to the whole line. So if, for example, you are trying to replace the / character within a selection on a line of an HTML or template file, this will screw up the closing tag of that line.

The trick here is to use %V in the matching portion.

:'<,'>s/\%Vsomething/something else/g

This restricts the match criteria to just the selection! Checkout :help %V.

Pretty format a json file in vim with jq

Viewing a minified or unformatted json in vim can be a headache. But luckily for us, that's an easy fix if you have jq installed. The following command will pass the contents of your current buffer to the jq external command for formatting:

:!% jq .

https://stedolan.github.io/jq/

Turning off a specific linter w/ALE

Ale comes configured with a set of default linters for each filetype it might encounter.

For typescript, if eslint is available as an executable, eslint will run, lint your code and display the results in vim. To turn off eslint for typescript you can set the variable g:ale_linters_ignore in your vimrc like this:

let g:ale_linters_ignore = {
      \   'typescript': ['eslint'],
      \}

Currently, I'm going through the typescript exercism track and I want to be able to play around a little bit with the syntax and would prefer not having a typescript linter at the moment.

Ergonomically select text between parens

Operating on text within parens is pretty straight forward for a regular vim user.

To select: vi( or vi)

To delete: di( or di(

But that hand stretch between shift and 9 or shift and 0 is sorta weird. Vim has a built in ergonomic shortcut for this operation though.

To select: vib

To delete: dib

Much easier on the ol' hands.

Picked this trick up watching the terrific Vim Un-Alphabet screencast series.

Use `g*` to go to the next word

Another trick I've learned from Vim Un-Alphabet is g*. You probably use the star command to find instances of a word throughout your file, and when you do that the search looks like this:

/\<word\>

The escaped angle brackets to the left and to the right are word boundaries. You can search for the word under the cursor without the word boundaries with g*.

Repeat subs with `g&` and `:&` and `:&&`

The tricks from Vim Un-Alphabet keep coming. Repeating your substitution is a cool trick and you can do it one of 3 ways.

g& will repeat the last substitution you did, but for the whole file, whatever file you're in at the moment.

:& will repeat the last substitution on the line you are on but you get to change the flags if you want. So you can decide now to make it global with :&g.

:&& will repeat the last substitution on the line you are on with the flags you used for that substitution.

3 very nice tricks to smooth out your workflow when making substitutions.

Jump to the last place you were in INSERT mode

I've known for a while that you can jump to the last place you edited with the gi command but it's always been slightly annoying to me that gi places you into INSERT mode.

To get back to the same place, but in NORMAL mode you can use the ^ mark by typing `^. This mark is reset everytime you leave edit mode. You can see what that mark is set to with :marks ^ Shoutout to Josh Branchaud and his Vim Un-Alphabet series for teaching me a new vim trick!

Word navigation when underscores are in the word

Phil Capel posted a til recently that talked about using the _ character as a word boundary by removing it from the iskeyword list with:

:se iskeyword-=_

So now w navigates to the next underscore in long_id_for_var and you can copy long with yiw when your cursor is on long.

My addendum to this is that navigating with W will still go to the next space separated word, B will go the beginning of the previous space separated word, and if your cursor is on long, yiW will copy long_if_for_var.

Use the word under the cursor with Ctrl-R Ctrl-A

Everybody at Hashrocket has some solution for searching for the word under the cursor.

Some people created a mapping, but as I try to keep to native vim functionality as much as possible I copied the current word with yiw and then typed:

:Rg <C-R>0

Where <C-R>0 writes whatever is in register 0 to the command.

Instead, the command mapping <C-R><C-A> writes the word currently under the cursor to the command, so I can just skip the yiw.

:Rg <C-R><C-A>

Will search for the word under the cursor.

See :help c_CTRL-R_CTRL-A for more info.

Use :helpgrep to search plugin help files too

I learned recently from Josh Branchaud's Vim Un-Alphabet screencast series about searching your help files with :helpgrep.

This works with the help files for your plugins too. For instance:

:helpgrep Author:  Tim Pope

Will search for the string "Author: Tim Pope" and will return entries for all plugins that Tim Pope authored that you have installed.

:set backupcopy=yes to trigger fs events for node

While trying to get hot module reloading working with parcel today I noticed that sometimes parcel's server didn't register when a file was saved.

It turns out that vim has some weird behaviour around writing files that prevents node's filesystem watcher from getting events that the file changed.

You can read about that weird behaviour here

You can get around this behaviour with:

:set backupcopy=yes

according to vim help backupcopy this will:

make a copy of the file and overwrite the original one

triggering the fs event.

UUIDs in Vim with Ruby/JavaScript 🆔

UUID's (universally unique identifiers) are really handy. I use them for all sorts of things, like key props in a React map, and I like to have them easily accessible when writing code.

Today I wrote two Vim mappings to support this workflow. I can shell out to Ruby and use SecureRandom:

" Insert a UUID with Ruby
nnoremap ruid :read !ruby -e "require 'securerandom'; p SecureRandom.uuid"<cr>

Or, if you're happier in the JavaScript ecosystem, here's a similar command using Node and the uuid library. I did not have to install uuid, it was already available to me.

" Insert a UUID with JS
nnoremap juid :read !node -e "var uuid = require('uuid'); console.log(uuid.v4())"<cr>

Change up to next underscore "_" in vim

ct_ will change up to the underscore and leave it be.

cf_ will change up to the underscore and eat it as well.

Alternatively, you can use set iskeyword-=_ which will make the "_" character a valid word boundary. This might be preferable if you, like me, tend to use ciw more often than just cw.

EDIT: Because iskeyword is how the syntax highlighting is managed, you'll probably notice that for methods/functions that contain keywords the highlighting is strange after playing with this. I found that I like nnoremap <leader>e :set iskeyword-=_<cr>diw:set iskeyword+=_<cr>i as a way to allow me to more easily edit the words I want without messing with the highlighting.

Change the CodeLens annotation color in CoC

CoC is the fanciest Language Server Protocol client for (neo)vim. It even implements Code Lens annotations, like reference counts in Javascript:

Ok neat. But by default, virtual text in neovim is in the normal highlight group. That means it looks just like code, and I'm already confused enough. After much source diving, I found that the highlight group used by CoC for this is CocCodeLens, and used like so:

:hi CocCodeLens guifg=White

My code is much more readable.

Vim Mark That Test! 🔖

This week Chris Erin taught me a technique that has changed my testing game: Vim mark your current Ruby test with mA.

When writing TDD-style code in a test-crazy language like Ruby, I tend to follow a predictable workflow: create a test, watch it fail, bounce around the code making changes, and run/edit the test again. This loop can repeat for hours on a complex feature.

There are many ways you could navigate back to your test from elsewhere; a very efficient method is to mark it in Vim with mA. Like any mark, you can return to it with `A. Why 'A'? Capitalized marks are file marks and are valid between files. With this command, you can mindlessly jump back to your test from anywhere in the jumplist stack.

Ergodox vim input for numpad keys can be wonky

I use the ergodox ez keyboard. When you're setting it up you can select either the numpad value of a key, or the shifted/regular value. These will behave slightly differently depending on your settings for application keypad mode. This is something that is set at the application layer, so you may end up dealing with vim recieing <esc>Ok if you are trying to type +. You can either try to find the way to get your application (in my case Manjaro's terminal emulator) to change the keypad mode (I couldn't find that), or you can setup an innoremap section in your vimrc to cover the cases where you definitely don't want the escape sequence.

:inoremap <Esc>Oq 1
:inoremap <Esc>Or 2
:inoremap <Esc>Os 3
:inoremap <Esc>Ot 4
:inoremap <Esc>Ou 5
:inoremap <Esc>Ov 6
:inoremap <Esc>Ow 7
:inoremap <Esc>Ox 8
:inoremap <Esc>Oy 9
:inoremap <Esc>Op 0
:inoremap <Esc>On .
:inoremap <Esc>OQ /
:inoremap <Esc>OR *
:inoremap <Esc>Ol +
:inoremap <Esc>OS -
:inoremap <Esc>OM <Enter>

This sequence is for PuTTY, but you can see which key to put after the <Esc>O by looking at what registers on keydown events. Alternatively, for ergodox users, only use the shifted/regular values for keys.

Search and Replace Control Characters In Vim

In vim, if you want to search and replace non-printable control characters (for example you have ^M scattered throughout your file and it's messing up an import) you can use ctrl+v+<char>. The ctrl+v allows you to type the control character, but you must hold down control for both of the key presses.

:%s/ctrl+v+M/

This would search and replace all non-printable ^M characters in your text.

Repeat Last Command Mode Command in Vim ♻️

To repeat your last Vim command mode command, use the @ register.

@:

After doing this once, continue to call the command with @@. A use case would be continuing to expand a pane in increments of two via :resize +2.

Add visual fold markers to Vim's gutter

TIL that you can display visual fold markers in Vim's gutter by setting the foldcolumn!

set foldcolumn=2

The number indicates how wide the gutter holding the fold marks should be.

Here it is in action:

This also makes the folds openable via mouse, which may be useful for some folks.

For more info: :h foldcolumn

Pass args to a custom vim command

Custom commands are easy in vim:

:command HelloWorld echo "hello world"
:HelloWorld
" outputs hello world

But what if I want to pass an arg to the command?

First you have to specify that you want args with the -narg flag. Then you need to have declare where the args would go with <q-args>.

:command! -narg=1 Say :echo "hello" <q-args>
:Say world
" outputs hello world

fill your quickfix window with lint

File names I can't jump to frustrate me. Today I ran $ npx eslint and my computer said "I looked at a file, and found a problem on this line, in this column. Do you want to see it? Good for you. Go type out the file name in your editor then."

ButI wanted a jump list of all the eslint errors in my project. Eslint is a kind of compiler, right? Vim knows compilers.

:set makeprg=npx\ eslint\ -f\ unix

Now I can

:make

and behold!

:cw

I can now see all of the errors and warnings for the project, and nimbly jump betwixt.

Vim Tags in Visual Mode 🏷

This is my 400th TIL! 🎉

I'll file this under 'Vim is endlessly composable'. Today I learned that Vim tags can be used to define a range in visual mode. Here's how you'd fold your code between two Vim tags.

Go to the first tag. If you marked it 1, here's how you'd do that:

m1

Enter visual mode and extend to your second tag 2:

m2

Enter command mode and fold the range:

:fold

Which automatically extends to:

:'<,'>fold

I use this in big markdown files to hide all but the thing I'm currently working on. Enjoy.

Vim Reverse Sort

I use Vim's :sort all the time. If I can't have a more meaningful algorithm than alphabetical, at least my lists are in some kind of order.

This function comes in surprisingly useful while writing GitHub-style checkbox lists.

- [x] Check mail
- [ ] Play guitar
- [x] Write TIL

Sorting this list alphabeticaly puts the undone items at the top.

- [ ] Play guitar
- [x] Check mail
- [x] Write TIL

Reverse the order (in classic Vim style) with a bang:

:sort!

Alternative to the escape key in Vim

Sometimes you need to escape, and you can't use the esc key. Whether its missing, on a touch bar, or you simply don't want to stretch your fingers away from home row, it's nice to have another option.

In Vim, Ctrl+[ sends an escape character, equivalent to pressing the escape key.

Now you can easily get back to normal mode.

Pretty-Print JSON in NeoVim/Vim using jq

I've written here before about how to pretty-print JSON in Vim but since then I have found an even easier method using jq.

jq is an amazing command line utility for processing, querying and formatting JSON. I use it all the time when I get a response from an API request and I want to extract information or simply to pretty-print it with colors. All you have to do is pipe the curl results into jq:

curl https://til.hashrocket.com/api/developer_posts.json?username=doriankarter | jq

You can also use jq inside of NeoVim to pretty print a JSON string, right in your buffer using this command:

:%!jq

Iterating Quickfix with Vim-Unimpaired 🏁

Vim's quickfix buffer is a place I spend a lot of time. Iterating through it can be done in a couple of ways:

:cprevious
:cnext
:cfirst
:clast

Or shortened:

:cp
:cn
:cfir
:cla

vim-unimpaired has some nice mappings to help.

[q     :cprevious
]q     :cnext
[Q     :cfirst
]Q     :clast

With [q and ]q we're flying through those results.

h/t Dorian