Mastering Vim grammar
Tags: vim, neovim, editor, grammar
Published: 2020-03-06 23:57:48

---
title: Mastering Vim grammar
published: true
description: Master Vim language's grammar
tags: vim, neovim, editor, grammar
canonical_url: https://irian.to/blogs/mastering-vim-grammar
---

*Follow [@learnvim](https://twitter.com/learnvim) for more Vim tips and tricks!*

Using [Vim](https://www.vim.org/) text editor can be overwhelming for many. If you're like me, your first exposure with Vim is when you accidentally opened it and couldn't get out. There is even a saying:

> *"Vim is hard to master, but harder to quit"*

Well, that was 4 years ago. Vim is now my primary text editor. I would like to share some tips how to become more productive with Vim without feeling overwhelmed by its many key combinations. 

To effectively use Vim, we must learn to speak its language *(not to be confused with [Vim Script](https://learnvimscriptthehardway.stevelosh.com/chapters/39.html))*. When we understand how to speak Vim language - I will refer it as *Vimish* in this article - it becomes more intuitive. Give is a try, and who knows, maybe you will end up switching over to Vim! 

*At the end of the day, use whatever editor that makes you most productive, because that is what matters most*.

# Learning Vimish

I am not a native English speaker. When I first moved to the US, it was hard for me to communicate. There were three things I did to build fluency: 
1. Increase vocabulary
2. Learn grammar rules
3. Practice, practice, practice. 

It takes initial work, but I think anyone can do it.

To learn Vimish, we need to do the same. I will share some vocabularies and a grammar rule. However, just like any language acquisition, repeated practice is required for mastery.

Let's start with grammar:

```
verb + noun
```

That's it. Next we will need to learn some nouns and verbs. Here I will cover:

1. Basic nouns (motions)
2. Verbs
3. More nouns (text objects)
4. Putting them together

Let's get started.

# Vim nouns (motions)

Some of you might already know Vim notions because they are what you use to navigate in normal mode. If you need refresher, you can check out this [article](https://irian.to/blogs/moving-around-in-vim). To read more about motion, check `:h motion.txt`.

For now, these should be more than enough:

- `h/j/k/l` - left/up/down/right
- `w,W` - word/ Word
- `b,B` - back a word/ Word
- `e,E` - end of word, Word
- `{/}` - paragraph forward/ backward
- `0/$` - beginning/ end of line

You can add quantifier to motions. For example, `j` is to go down one line. Typing `10j` lets us go down 10 lines instead of `jjjjjjjjjj`. Try to use quantifier instead of repeating same motion.


I mentioned motions here because they _also_ work as nouns in Vimish *when combined with verbs*. Let's learn some verbs.

## Vim verbs
Vim has many operators (16 at the time of the writing. Check `:h operator` for more. You can also add an additional operators using plugins). However, in my experience, learning these 3 operators is enough to do 95% of editing.
- `y` - yank (copy)
- `d` - delete
- `c` - change

Now that we know our motions and operators, let's construct our sentence with `verb + noun` grammar in mind. Let's say you have the following:

```javascript
const learn = "vim"; // cursor on c
```

- To **delete** a **word**, do `dw`. Verb (`d`) + noun (`w`). 

- To **yank** everything from your current location to the end of the line, do `y$` _(paste with `p` or `P`)_. Verb (`y`) + noun (`$`).

- To **change** the entire **paragraph** ahead,  do `c}`. Verb (`c`) + noun (`{`).

By the way, we can add quantifiers to our grammar. For example:

- To **delete** the next **two words**, do `d2w`.

- To **change** the next two lines, do `c2j`.

- To **yank** the last two letters, do `y2h`.


A side note:  although the result of  `2dw` is equivalent to `d2w`, they are technically different.  `2dw` means *perform "deletion of a word" two times*  `d2w` means *delete the next two words one time. The difference is what Vim considers as "a change” and this matters if you are using dot command. So use your quantifiers wisely. You can read about Vim’s dot command [here](https://irian.to/blogs/use-vims-dot-command-to-do-repetitive-tasks-faster/).

One more side note about Vim operators, is that you can type them twice to perform the operation on the entire line. `dd`,`yy`, and `cc` perform  **deletion**, **yank**, and **change** on the entire line.

Once you grasp the basic verbs and nouns, it becomes intuitive. The goal is to practice enough so you won't have to think anymore. Just like learning a new language, you want to be able to speak it with no effort at all. 

I think this [compositional](http://ismail.badawi.io/blog/2014/04/23/the-compositional-nature-of-vim/) nature is where Vim shines. By learning these 3 verbs and a handful of nouns, we can create powerful instructions.

We are not quite done yet - let's continue with Vim's most powerful nouns: text objects.

## Vim Nouns (Text Objects)

What if I am in the middle of a word I want to delete? Do I have to go back to the start of that word (`b`) and delete the word `dw`? 

Vim allows you to delete the "group" you’re in the middle of. It works with paragraph, bracket pairs, quote pairs, etc. Anything that surrounds you. These are called text objects. To use text objects:

- Inner: `i` + object 
- Outer: `a` + object 
 
Suppose I have this function:

```javascript

const hello = function() {
  console.log("Hello World"); // your cursor is on letter H in Hello World
  return;
}
```

- To delete the entire "Hello World", do `di(`. Verb (`d`) + noun (`i(`)
- To delete the entire function content, do `di{`. Verb (`d`) + noun (`i{`)
- To delete the entire "Hello" string but keep "World" string, do `diw`. Verb (`d`) + noun (`iw`)

Here are some common text objects:
- `w` - word
- `p` - paragraph
- `( { [ <` - brackets
- `t` - XML tags
- `" '` - quotes

## Bonus: even more nouns
Vim nouns are not limited to motions and text objects. We can use search too. For example:

- `f / F`- inclusive forward/backward search, same line
- `t / T` - exclusive forward/backward search, same line
- `/ / ?` - forward/ backward search

Applying this to our grammar:

- To delete from current location to first instance of "z", do `dfz`. Verb (`d`) + noun (`fz` - find z).
- To delete everything to the third "e", do `d3fe`.
- To delete everything from your current location, backwards, to first "a", do `dFa`.
- To delete everything up to, excluding "x", `dtx`
- To delete the line you are on to the next instance of "const hello", `d/hello`.

Verbs also work with marks. Example of a mark:
- `ma` (mark position on register "a")

Mark can be used with any letter of the alphabets (a-z), so you can make up to 26 marks (technically 52 if you count global marks, but that's a separate discussion). Recall to jump to mark, you can either:
- `'a` (jump to the start of line marked a)
-  `` `a ``(jump to the line and column of line marked a)


To use mark as noun, you can mark a spot, go before/ after the mark, then `d'a` to delete everything between your current position and `a` mark.



# Putting it all together
We just learned Vim grammar basic:

```
Verb + noun
```

We learned some Vim verbs and nouns: operators and motions. Operators (`d`,`y`,`c`) make up basic verbs. Motions, text-objects, searches, and marks make up most of our nouns. There are many more verbs and nouns out there. I have only mentioned a fraction of them. Similar to language acquisition, learning Vim takes time before it comes naturally. But once we learn how to speak Vimish, we can unleash powerful commands. 

You will notice that you can apply this rule with many commands. One of my biggest Vim AHA moment was when I started applying this grammar rule with new operators on my own. For example, `gu` and `gU` are operators to lowercase and uppercase, respectively. Because they are *operators*, they can be used with nouns. `guiw` lowercases a word. `gU$` uppercases from current location to end of line. I just intuitively did it and it worked - because they follow the same grammar rule. I hope you will have your AHA moment soon, if not already.


Turning this knowledge learned into muscle memory will not happen over a weekend. It will take longer. I have imparted what I know and now it is up to you to apply it. Thank you for reading this far, I appreciate it. 

Happy coding!

# Resources
- [Learn to speak vim — verbs, nouns, and modifiers!](https://yanpritzker.com/learn-to-speak-vim-verbs-nouns-and-modifiers-d7bfed1f6b2d)
- [Vim grammar](https://takac.github.io/2013/01/30/vim-grammar/)
- [Grokking Vi](https://stackoverflow.com/questions/1218390/what-is-your-most-productive-shortcut-with-vim/1220118#1220118)
- [Vim as a language](https://benmccormick.org/2014/07/02/learning-vim-in-2014-vim-as-language)
- [Mastering the Vim Language](https://www.youtube.com/watch?v=wlR5gYd6um0&t=1s)