# Vim Grammar It is easy to get intimidated by the complexity of many Vim commands. If you see a Vim user doing `gUfV` or `1GdG`, you may not immediately know what these commands do. In this chapter, I will break down the general structure of Vim commands into a simple grammar rule. This is the most important chapter in the entire book. Once you understand Vim commands' grammar-like structure, you will be able to "speak" to Vim. By the way, when I say *Vim language* in this chapter, I am not talking about Vimscript (the built-in programming language to customize and to create Vim plugins). Here it means the general pattern of normal mode commands. # How to learn a language I am not a native English speaker. I learned English when I was 13 when I moved to the US. I had to do three things to build up linguistic proficiency: 1. Learn grammar rules 2. Increase my vocabulary 3. Practice, practice, practice. Likewise, to speak Vim language, you need to learn the grammar rules, increase your vocabulary, and practice until you can run the commands without thinking. # Grammar Rule You only need to know one grammar rule to speak Vim language: ``` verb + noun ``` That's it! This is equivalent to saying these English phrases: - *"Eat (verb) a donut (noun)"* - *"Kick (verb) a ball (noun)"* - *"Learn (verb) the Vim editor (noun)"* Now you need to build up your vocabulary with basic Vim verbs and nouns. # Vocabulary ## Nouns (Motions) Let's talk about motions as nouns. Motions are used to move around in Vim. They are also Vim nouns. Below you'll see some motion examples : ``` h Left j Down k Up l Right w Move forward to the beginning of the next word } Jump to the next paragraph $ Go to the end of the line ``` You will learn more about motions in the next chapter, so don't worry too much if you don't understand some of them. ## Verbs (Operators) According to `:h operator`, Vim has 16 operators. However, in my experience, learning these 3 operators is enough for 80% of my editing needs: ``` y Yank text (copy) d Delete text and save to register c Delete text, save to register, and start insert mode ``` Now that you know basic nouns and verbs, let's apply our grammar rule! Suppose you have this expression: ``` const learn = "vim"; ``` - To yank everything from your current location to the end of the line: `y$`. - To delete from your current location to the beginning of the next word: `dw`. - To change from your current location to the end of the current paragraph, say `c}`. Motions also accept count number as arguments *(I will discuss this further in the next chapter)*. If you need to go up 3 lines, instead of pressing `k` 3 times, you can do `3k`. Count works with Vim grammar. - To yank two characters to the left: `y2h`. - To delete the next two words: `d2w`. - To change the next two lines: `c2j`. Right now, you may have to think long and hard to do even a simple command. You're not alone. When I first started, I had similar struggles but I got faster in time. So will you. As a side note, linewise operations are common operations in text editing, so Vim allows you to perform linewise operation by typing the operator command twice. For example, `dd`, `yy`, and `cc` perform **deletion**, **yank**, and **change** on the entire line. Try this with other operators! I hope everything starts to make sense. But I am not quite done yet. Vim has one more type of noun: text objects. ## More Nouns (Text Objects) Imagine you are somewhere inside a pair of parentheses like `(hello vim)` and you need to delete the entire phrase inside the parentheses. How can you quickly do it? Is there a way to delete the "group" you are inside of? The answer is yes. Texts often come structured. They are often put inside parentheses, quotes, brackets, braces, and so on. Vim has a way to capture this structure with text objects. Text objects are used with operators. There are two types of text objects: ``` i + object Inner text object a + object Outer text object ``` Inner text object selects the object inside *without* the white space or the surrounding objects. Outer text object selects the object inside *including* the white space or the surrounding objects. Outer text object always selects more text than inner text object. So if your cursor is somewhere inside the parentheses in the expression `(hello vim)`: - To delete the text inside the parentheses without deleting the parentheses: `di(`. - To delete the parentheses and the text inside: `da(`. Let's look at a different example. Suppose you have this Javascript function and your cursor is on "Hello": ``` const hello = function() { console.log("Hello Vim"); return true; } ``` - To delete the entire "Hello Vim": `di(`. - To delete the content of function (surrounded by `{}`): `di{`. - To delete the "Hello" string: `diw`. Text objects are powerful because you can target different objects from one location. You can delete the objects inside the pair of parentheses, the function block, or the whole word. Moreover, when you see `di(`, `di{`, and `diw`, you get a pretty good idea what text objects they represent (a pair of parentheses, a pair of braces, and a word). Let's look at one last example. Suppose you have these HTML tags: ```
Paragraph1
Paragraph2