Editing Like Magic With Vim Operators
Tags: productivity, vscode, vim
Published: 2019-06-24 19:18:30

---
title: Editing Like Magic With Vim Operators
published: true
description: Where you learn how to combine the power of motions with the super power of operators to edit text at the speed of thought, like if it were magic
tags: [productivity,vscode,vim]
canonical_url: https://www.barbarianmeetscoding.com/boost-your-coding-fu-with-vscode-and-vim/editing-like-magic-with-vim-operators/
cover_image: https://www.barbarianmeetscoding.com/images/boost-coding-fu-vscode-vim-banner.jpg
series: Boost Your Coding Fu With VSCode and Vim
---

> This is a chapter [Editing Like Magic with Vim Operators](https://www.barbarianmeetscoding.com/boost-your-coding-fu-with-vscode-and-vim/editing-like-magic-with-vim-operators/) from the book [Boosting Your Coding Fu with VSCode and Vim](https://www.barbarianmeetscoding.com/boost-your-coding-fu-with-vscode-and-vim)

Motions aren't just for moving. They can be used in combination with a series of commands called **operators** to edit your code at the speed of lightning. 

You can use operators and motions together by following any of these patterns:

```
{operator}{count}{motion}
{count}{operator}{motion}
```

![](https://www.barbarianmeetscoding.com/images/vim-operators.jpg)

- The **operator** determines which action you want to perform: deleting, changing, yanking, formatting, etc.
- The **count** allows you to multiply the effect of an operator by performing an action a *count* number of times.
- The **motion** represents the piece of text to which to apply the action defined by the operator.

For instance, the `d2w` combination allows you to **delete two words** [^almost].

![](https://www.barbarianmeetscoding.com/images/vim-operators-d2w.jpg)

[^almost]: To be more accurate, `d2w` allows you to delete all the text from the cursor until the beginning of the second word. For the time being, let's just say that it deletes two words and we'll get around to correctness soon enough.

**`d`** corresponds to the **delete** operator. Since **`d`** is an operator, you can follow the `{operator}{count}{motion}` formula and combine it with all the motions you've learned thus far:

- Use **`d5j`** to delete 5 lines downwards
- Type **`df'`** to delete everything in the current line from the cursor until the first occurrence of the **`'`** character (including the character itself)
- Or type **`dt'`** to do like the above example but excluding the character (so up until or just before the **`'`** character)
- Use **`d/hello`** to delete everything until the first occurrence of **`hello`**
- Type **`ggdG`** to delete a complete document

## Useful Operators

![](https://www.barbarianmeetscoding.com/images/vim-operators-commands.jpg)

In addition to **`d`**, there's a handful more of handy operators:

- **`c`** (**c**hange): Change deletes a piece of text and then sends you into *Insert mode* so that you can continue typing, changing the original text into something else. The change operator is like the **`d`** and **`i`** commands combined into one[^two]. This duality makes it the most useful operator
- **`y`** (**y**ank): Copy in Vim jargon
- **`p`** (**p**ut): Paste in Vim jargon
- **`g~`** (switch case): Changes letters from lowercase to uppercase and back. Alternatively, use **`gu`** to make something lowercase and **`gU`** to make something uppercase
- **`>`** (shift right): Adds indentation
- **`<`** (shift left): Removes indentation
- **`=`** (format code): Formats code

[^two]: Two commands in one? Sounds great to me!

You can use these operators much like you used **delete** so that:

* **`c/hello`** changes everything until the first occurrence of `hello`.
* **`ggyG`** copies a whole document
* **`gUw`** capitalizes a word

## Operator Shorthand Syntax

All these operators provide additional shorthand syntax aimed at saving you typing and increasing your speed with common editing tasks:

- **Double an operator to make it operate on a whole line**: **`dd`** deletes a whole like, **`cc`** changes a whole line, etc.
- **Capitalize an operator to have it perform a stronger (or alternate) version of its default behavior**: **`D`** deletes from the cursor to the end of the line, **`C`** changes to the end of a line, **`Y`** like **`yy`** copies a complete line, **`P`** pastes something before the cursor, etc.

> ### Noticed How Command Keys Make a Lot of Sense?
> 
> Operators, motions and other commands in Vim are generally easy to learn because they make sense and are easy to guess. Want to change something? You probably want to use the **`c`** (**c**hange) operator. Want to move word by word? Try **`w`** (**w**ord). Want to delete something? Try the **`d`** (**d**elete) operator and so on.

Operators really shine when we combine them with a special class of motions called **text-objects**.

## Taking Editing Up a Notch With Text Objects

Text objects are structured pieces of text or, if you will, the entities of a document domain model. What is a document composed of? Words, sentences, quoted text, paragraphs, blocks, (HTML) tags, etc. **These are text objects.**

The way that you specify a text object within a command is by combining the letter **`a`** (**a** text object plus whitespace) or **`i`** (**inner** object without whitespace) with a character that represents a text object itself: 

![](https://www.barbarianmeetscoding.com/images/vim-text-objects.jpg)

```
{operator}{a|i}{text-object}
```

The built-in text-objects are:

![](https://www.barbarianmeetscoding.com/images/vim-text-objects-commands.jpg)

* **`w`** for **w**ord
* **`s`** for **s**entence
* **`'`**, **`"`**, **`` ` ``** for quotes
* **`p`** for **p**aragraph
* **`b`** (or **`(`**, **`)`**) for block surrounded by **`()`,** 
* **`B`** (or **`{`**, **`}`**) for block surrounded by **`{}`**
* **`<`**, **`>`** for a block surrounded by **`<>`**
* **`[`**, **`]`** for a block surrounded by **`[]`**
* **`t`** for tag. 

So in order to delete different bits of text you could any of the following commands:

- **`daw`** to **d**elete **a** **w**ord (plus trailing whitespace)
- **`ciw`** to **c**hange **i**nner **w**ord
- **`das`** to **d**elete **a** **s**entence (**`dis`** to delete inner sentence)
- **`da"`** to delete something in double quotes including the quotes themselves (**`di"`** deletes only the content **i**nside the quotes and spares the quotes)
- **`ci"`** to change something inside double quotes
- **`dap`** to delete a paragraph
- **`dab`** **`da(`** or **`da)`** to delete a block surrounded by **`(`**
- **`daB`** **`da{`** or **`da}`** to delete a block surrounded by **`{`**
- **`dat`** to delete an HTML tag
- **`cit`** to change the contents of an HTML tag

**Combining text objects with operators is extremely powerful** and you'll find yourself relying on them very frequently. Stuff like `cit`, `ci"` and `cib` is just brilliant.

Let's say that we want to change the contents of this string below for something else:

```javascript
const salute = 'I salute you oh Mighty Warrior'
```

You type `ci'Hi!<ESC>` and it becomes:

```javascript
const salute = 'Hi!'
```

Just like that. You don't need to go grab the mouse, select the text and then write something else. You type three letters and Boom! You're done.

> ### Noticed How Most Vim Keys Are Placed Near Your Fingers?
>
> The fact that Vim has modes allows keys near the home row to be reused in each separate mode. This design decision minimizes the need for slow and contorted key combinations, and heightens your speed and the longevity of your fingers and wrists. **This is awesome!**

## Repeating The Last Change with The Dot Operator

Vim has yet another trick in store for you aimed at saving more keystrokes: The magic **`.`** (dot) command. 

![](https://www.barbarianmeetscoding.com/images/vim-dot-command.jpg)

**The `.` command allows you to repeat the last change you made**. Imagine that you run **`dd`** to delete a line of code. And now let's say that you've warmed up to removing code. Removing code is good, the less code you have the less code you need to maintain. So let's remove another line of code. How would you go about that? You could type **`dd`** again but, even better, you could use the **`.`** command which is just a single keystroke. 

OK. You save one keystroke. So What. (Tough crowd here I see). Well, you can use the **`.`** command to repeat **any type of change**, not just a single shorthand command like `dd`. For instance, you could change a word for `Awesome` like so `cawAwesome<Enter>`, and then repeat that whole command with all those keystrokes by just typing a single dot. Think of the possibilities!

The **`.`** command becomes even more useful if you get in the habit of using Text-objects. Text-objects are more reliable than other motions because you don't need to care as much where the cursor is positioned. Thus, commands with text objects are far more repeatable and therefore work beautifully in tandem with the **`.`** command.

The **`.`** command works great in combination with the repeat search commands (**`;`**, **`,`**, **`n`** or **`N`**). Imagine that you want to delete all occurrences of `cucumber`. A possible approach would be to search for cucumber `/cucumber`, delete it with **`daw`** and, from then on, use **`n`** to go to the next match and **`.`** to delete it! Two keystrokes!?! Again think of the possibilities!!

## More Shorthand Text Editing Commands

In addition to the operators you've learned in this chapter, Vim offers a series of shortcuts to operate on single characters that can be useful on occasion. They are:

* **`x`** is equivalent to **`dl`** and deletes the character under the cursor
* **`X`** is equivalent to **`dh`** and deletes the character before the cursor
* **`s`** is equivalent to **`ch`**, deletes the character under the cursor and puts you into *Insert mode*
* **`~`** to switch case for a single character

As usual, all of the above support counts to operate on multiple characters at once.

## Undoing and Redoing

Sooner or later it will come a time when you will make a mistake.  Admit it! You ain't perfect. Nobody is. And that is alright. You needn't worry though, because Vim has your back:

* Type **`u`** and you'll undo your last change,
* Type **`CTRL-R`** and you'll redo it, 

*Pheeewww...*

## Summary

**Motions aren't just for moving. Used in combination with operators they let you perform operations on text with ease and amazing speed**. You apply an operator on a motion by using the key melody `{operator}{motion}`.

Some of the most useful and common operators are: **`d`** for **d**elete, **`c`** for **c**hange, **`y`** for **y**ank (copy) and **`p`** for **p**ut (paste). As you can appreciate from these operators and the motions you've learned thus far, Vim commands are generally easy to learn because they make sense and are easy to guess.

**When you double an operator you make it operate on a line**. For instance, you can use **`dd`** to delete a complete line. In a similar fashion, **when you capitalize a command it performs a stronger (or alternate) version of the original command**. For example, **`D`** deletes from the cursor to the end of a line. These are really helpful and can save you a lot of time. Learn to use them instead of their more wordy alternatives.

**Counts also work with operators**. You can multiply the effect of an operator motion combo by using a count like this: `{operator}{count}{motion}`.

**Text objects are special motions that describe the parts of a document: words, sentences, paragraphs, and such**. They are incredibly useful in combination with Vim operators. **Using operators with text-objects you can be very precise and command Vim to delete a word, or change the insides of a string or code block**.

Text objects offers two variants: the **`a`** (think **a** or **a**ll) and **`i`** (think **i**nner) that allow you to operate on a text object plus surrounding whitespace or only on the inner parts of a text object respectively. For example, using **`da"`** deletes a complete quote including trailing whitespace, using **`di"`** only deletes whatever is surrounded by quotes.

**The dot command `.` lets you repeat the last change** and, as such, it is one of the most useful repeater commands. **Operations on text-objects are great candidates for the dot operator because they are more repeatable**.

**A great way to take advantage of the dot command is by using it in combination with searches**. When you do that you can apply changes of successive searches with just two keystrokes: **`n`** or **`;`** to find the next match and **`.`** to repeat the last change. 

Sometimes you'll make a mistake. When that happens, **you can undo the last change with the `u` command**. If you change your mind or undo too far, type `CTRL-R` to **r**edo.