For devs, text editors are the ultimate multitools, shaping how we create, manage, and transform raw data into meaningful output.

While modern editors like VS Code and Sublime Text have gained popularity for their sleek interfaces, there’s something timeless about the simplicity and power of classic tools.

Loved by some and feared by others, Vim is a text editor that has stood the test of time. Born from its predecessor Vi, Vim (Vi Improved) offers unparalleled speed, versatility, and control.

In this tutorial, you’ll learn what makes Vim so special. We’ll explore its commands, text filtering, and string manipulation capabilities to help you harness its true power.

What we’ll cover:

1. Text Editors in Linux

2. How to Open the Vim Editor

3. Modes in Vim

4. Basic Vim Commands

5. Cut, Copy, Paste, and Delete Commands

6. Search and Replace Commands

7. How to Read Files using more and less

8. Text Filters

9. Text Summarization Tool: wc

Text Editors in Linux

Linux provides a variety of text editors, each designed for different types of users – from beginners to advanced developers.

Editors like Nano are great for newcomers who need a simple, user-friendly experience in the terminal. Nano displays helpful commands at the bottom of the screen, making it easy to navigate without a steep learning curve.

Gedit, the default editor for the GNOME desktop environment, offers a clean, graphical interface ideal for basic text editing. On the other hand, Kate caters to KDE desktop users and provides a more feature-rich experience, with multiple windows, syntax highlighting, and an integrated terminal.

Emacs is a versatile and highly customizable editor that can be turned into an entire development environment, ideal for power users who want more than just a text editor.

VS Code and Atom are modern, graphical editors that offer a rich set of features, including extensions, debugging tools, and Git integration, making them favorites among developers.

Why Do Many Devs Prefer Vim?

Despite the wide range of text editors available in Linux, Vim stands out as the preferred choice for many users, especially those who need a lightweight, fast, and highly efficient editing environment.

Vim, an improved version of the classic Vi editor, is available on nearly every Linux distribution and can be used in both graphical and terminal-based environments. Its popularity stems from its exceptional speed and efficiency.

Vim is entirely keyboard-driven, allowing you to perform complex editing tasks quickly without the need for a mouse. This makes it incredibly useful for remote work, where you may have to rely on minimal system resources.

The power of Vim lies in its modal editing system, which separates the text input and command modes, which you’ll learn soon. This lets you execute precise actions with a few keystrokes. Whether you're navigating a file, searching for a string, or performing complex text manipulations, Vim enables you to do it all without taking your hands off the keyboard.

Because Vim (or Vi) is pre-installed on most Linux systems, it’s often the go-to option for developers and system administrators, who rely on its ubiquity and powerful features. In short, Vim’s combination of speed, versatility, and efficiency makes it the editor of choice for many Linux users looking to boost their productivity.

How to Open the Vim Editor

Opening a file in Vim is straightforward and efficient. To start editing any file, simply use the following command in your terminal:

vim [filename]

Here, replace [filename] with the name of the file you want to open. If the file doesn't exist, Vim will create a new file with that name. Once executed, Vim will open the file and allow you to start editing right away.

Example:

vim data.txt # A file that doesn't exist yet, so Vim creates a new file named data.txt

When you execute the command vim data.txt, Vim opened a new file named data.txt because a file with this name did not previously exist in the current directory. In Vim, this is indicated by the message at the bottom of the editor, which reads: data.txt [NEW]

If the file you want to edit already exists, you can open it in Vim by using the same command. You’ll be able to see its contents and make edits as needed. If you don’t see the [New] message at the bottom (as shown for new files), it confirms the file already exists.

Modes in Vim

Vim has several modes, but the most commonly used ones are:

• Normal Mode (Command Mode) – Used for navigation and executing commands.

• Insert Mode – Used for typing and editing text.

When you open a file in Vim, it starts in Command Mode by default. This mode allows you to navigate, execute commands, and perform various operations without directly modifying the text. To edit the text in the file, you need to switch to Insert Mode.

What is Command Mode?

Command Mode is the default mode in Vim. In this mode, you can navigate through the file using the arrow keys and cut, copy, paste, or delete the content and execute commands like saving or quitting.

To switch to Command Mode from any other mode, press the Esc key.

Example: If you are in Insert Mode and need to return to Command Mode to save or navigate, press Esc.

In the above image, "hello.txt" 1L, 1B” indicates that the file hello.txt is open and is currently in Command Mode, which is the default mode when you open Vim. 1L Represents 1 line in the file (currently the file is empty, so there’s just one blank line). 1B Represents 1 byte (the file is currently empty)

What is Insert Mode?

Insert Mode allows you to edit or type text in the file, similar to a traditional text editor. You can insert new lines, modify existing text, and make changes directly.

Press i while in Command Mode. This switches to Insert Mode and places the cursor at the current position, allowing you to start typing.

In the above image, “—INSERT—” indicates that the editor has been switched to Insert Mode, allowing you to type and edit text directly in the file.

Quick glance: When you open a file, always check the bottom of the terminal to determine your current mode. If the bottom line displays file-related information, you are in Command Mode. If the bottom line explicitly says -- INSERT --, you are in Insert Mode. If you want to go from Command Mode to Insert Mode: Press i. And from Insert Mode to Command Mode: Press Esc.

Basic Vim Commands

Below are some essential commands to help you manage files efficiently in Vim.

Note: Before using these commands, ensure you're in command mode by pressing Esc.

1. Save Changes

To save the changes made to a file, use the following command:

:w

This writes (saves) the current file without exiting Vim.

2. Save Changes and Quit

If you're done editing and want to save changes and exit Vim simultaneously, use:

:wq

This command writes the changes and then quits the editor.

3. Quit Without Saving Changes

If you wish to exit without saving any changes, you can use:

:q

This command will close the file if no changes have been made since the last save.

4. Force Quit Without Saving Changes

In case you've made changes to the file but want to exit without saving them, you can force quit with:

:q!

The ! overrides any unsaved changes and closes the file immediately.

Cut, Copy, Paste, and Delete Commands (Plus Others)

How to Position the Cursor for Text Manipulation

Before using any of the commands listed below (copy, cut, paste, and delete), it's important to understand where to place the cursor.

• Copy (Yank), Cut, Delete: For most operations, the cursor needs to be placed at the starting point of the text you want to act upon. This means if you're copying or cutting a word, place the cursor at the beginning of the word. If you're working with a line, the cursor should be anywhere on that line. For paragraph-based operations, position the cursor anywhere within the paragraph.

• Paste: The text will be pasted at the cursor's current position. So, ensure your cursor is placed where you want the copied or cut content to appear.

For example, Let’s say I have a file.txt that has the following content -

# file.txt
Hey readers,  
In this blog, we're learning Vim. This file is for demonstration purposes,
where we'll explore various editing commands like cut, copy, paste, and delete. Let's dive in!  

Vim is a powerful text editor that comes pre-installed on most Unix-based systems.
Mastering Vim can significantly boost your efficiency as a developer.  

To start with, let's learn some basic navigation and text manipulation commands.
Stay tuned as we break down each command with examples!

All the commands mentioned below will use this file as reference to explain examples.

1. Copy (Yank)

In Vim, copying is called "yanking." Use the following commands to copy text. The cursor's position is important to ensure the correct text is copied.

2. Cut (Change)

Cutting in Vim is known as "changing" the text. The cut operation replaces the text. Just like with copying, the cursor's position is important when using cut commands.

3. Paste

To paste the copied or cut text, use the following commands. The pasted text will appear at the current cursor position.

4. Delete

Deleting text in Vim allows you to remove unwanted text while remaining in command mode. The cursor must be positioned correctly to delete the intended text. Once deleted, you can still paste the deleted text to a new location.

5. Other Useful Commands

Note that Delete removes text but doesn’t store it in the system clipboard by default. The text goes into Vim’s unnamed register, meaning it can be pasted within Vim but not outside it. Cut explicitly stores text in the clipboard so you can paste it outside Vim as well.

Search and Replace Commands

Vim provides powerful search and replace functionality that allows you to find specific words or patterns and replace them efficiently. Understanding how to search and replace text is key to improving your productivity when editing large files.

Below is a breakdown of the various search and replace commands in Vim.

Search Commands

• Search Forward (/): When you want to search for a word or pattern below the cursor, use the / command. This will search forward in the file.

• Search Backward (?): Similarly, if you want to search for a word or pattern above the cursor, use the ? command. This will search backward in the file.

After performing a search, you can navigate through the search results:

• n: Go to the next match in the same direction (forward if /, backward if ?).

• N: Go to the previous match in the opposite direction (backward if /, forward if ?).

Replace Commands

Once you've located the word or pattern you want to replace, Vim provides several commands for replacing text.

Here’s an example:

In Vim, the /Tanishka pattern searches for an exact, case-sensitive match of the word "Tanishka."

To replace "Tanishka" with another word, like "Linux," you can use the substitution command like this: :s/Tanishka/Linux:

By default, this command replaces only the first occurrence of "Tanishka" in the line where the cursor is located.

If you want to replace all occurrences of "Tanishka" in the same line, you need to add the g (global) flag after the replacement string like this: :s/Tanishka/Linux/g.

This ensures that every instance of "Tanishka" in the current line is replaced with "Linux."

Similarly, the % symbol is used to specify the entire file when performing a substitution. Here's how it works in combination with the substitution command:

1. Replace the first occurrence in each line of the file:

   • :%s/Tanishka/Linux: This command replaces only the first occurrence of "Tanishka" in each line of the file.

2. Replace all occurrences in the entire file:

   • :%s/Tanishka/Linux/g: The addition of the g (global) flag ensures that all occurrences of "Tanishka" in every line of the file are replaced with "Linux."

How to Read Files using more and less

The cat command

The cat command is often used to read file content.

For example:

cat file.txt # Displays content of file

While the cat command is a straightforward tool for viewing file contents, its simplicity often falls short when working with large files or when precise navigation is required. That’s where the more and less commands come into play, offering enhanced functionality for viewing and navigating text efficiently.

The more Command

The more command allows you to view files one screen at a time, making it a significant upgrade from cat when dealing with large files. But it comes with limitations in terms of backward navigation and advanced features.

Here’s the syntax for more:

more [FILENAME]

And here’s an example:

more file.txt # Displays content of file.txt one page at a time

Keys used while viewing:

1. Spacebar: Moves forward by one page

2. Enter: Moves forward by one line

3. b: Moves back by one page

4. q: Quit and exit file content

The less Command

The less command is often considered a superior alternative to more due to its advanced navigation capabilities and flexibility. Unlike more, less allows both forward and backward navigation, making it ideal for reviewing large files or logs.

Here’s its syntax:

less [FILENAME]

And here’s an example:

less file.txt # Displays content of file.txt one page at a time

Keys used while viewing:

1. Spacebar: Moves forward by one page

2. Enter: Moves forward by one line

3. b: Moves back by one page

4. Up/Down arrow key: Moves up or down by one line

5. q: Quit and exit less

The only major difference between the more and less commands is that the less command allows bidirectional navigation, so it’s typically more convenient to use.

Text Filters

A text filter in Linux is a command-line utility that processes text data by modifying, extracting, or formatting it before outputting the result.

Horizontal filters

Horizontal filtering focuses on extracting, manipulating, or displaying specific lines of a file or command output. Common tools include head, tail, and grep.

1. head: The head command displays the first few lines of a file. By default, it shows the first 10 lines. Here’s its syntax:

    head [OPTIONS] [FILENAME]
   

   And here’s an example of how to use it:

    head file.txt # Displays first ten lines from file.txt
    head -n 5 file.txt # Displays first five lines from file.txt
   

2. tail: The tail command displays the last few lines of a file. By default, it shows the last 10 lines. Here’s its syntax:

    tail [OPTIONS] [FILENAME]
   

   And here’s an example:

    tail file.txt # Displays last ten lines from file.txt
    tail -n 5 file.txt # Displays last five lines from file.txt
   

3. grep: The grep command searches for patterns within a file or input. It filters out lines that match a given pattern. Here’s its syntax:

    grep [OPTIONS] [PATTERN] [FILENAME]
   

   Options:

   • -i: Case-insensitive search.

   • -v: Invert the match (exclude matching lines).

   • -n: Show line numbers of matches.

Example

    grep Tanishka data.txt # Displays lines that have 'Tanishka' in them
    grep -i Tanishka data.txt # Displays lines that have 'Tanishka' irrespective of case
    grep -v Tanishka data.txt # Displays lines that do not have 'Tanishka' in them
    grep -n Tanishka data.txt # Displays lines that have 'Tanishka' in them along with number line

Vertical Filters

1. cut: The cut command displays selected parts of lines from each file based on delimiters, byte positions, or character fields. Here’s its syntax:

    cut [OPTION] [FILENAME]
   

   It also comes with various options:

   • -c: Extract specific characters.

   • -b: Extract specific bytes.

   • -d: Specify a custom delimiter (default is tab).

     • cut -d ":" -f 2 file.txt → Second field separated by :.

   • -f: Extract specific fields.

     • cut -d "," -f 1,3 file.csv → Fields 1 and 3 from a CSV.

Example:

    cut -c 1-10 Sample.txt # Displays characters from position 1 to 10
    cut -c 5 Sample.txt # Displays character at position 5
    cut -c 3,5 Sample.txt # Displays characters from position 3 and 5 only
    cut -d " " -f 1 Sample.txt # Displays first field separated by a space
    cut -d " " -f 2 Sample.txt # Displays second field separated by a space
    cut -d " " -f 3 Sample.txt # Displays third field separated by a space
    cut -d " " -f 1-3 Sample.txt # Displays first to third fields separated by a space
    cut -d " " -f 1,3 Sample.txt # Displays first and third fields separated by a space
    cut -d ":" -f 5 /etc/passwd # Displays fifth field separated by : in /etc/passwd

Text Summarization Tool: wc

The wc (word count) command is used to display the number of lines, words, characters, or bytes in a file or input. It is a simple yet powerful utility you can use to summarize text content.

Here’s its syntax:

wc [OPTION] [FILENAME]

And here are its options:

• -l: Displays the number of lines.

• -w: Displays the number of words.

• -c: Displays the number of bytes.

• -m: Displays the number of characters (useful for multibyte characters).

• -L: Displays the length of the longest line.

Example:

wc Sample.txt # Displays line count, word count, and byte count in Sample.txt
wc -w Sample.txt # Displays number of words in Sample.txt
wc -l Sample.txt # Displays number of lines in Sample.txt
wc -L Sample.txt # Displays number of characters in longest line in Sample.txt

wc -c Sample.txt # Displays number of bytes in Sample.txt (Actual storage size)
wc -m Sample.txt # Displays number of characters in Sample.txt (Actual number of characters regardless of enoing)

# ABCD😄
wc -c above.txt # "ABCD" = 4 bytes + "😄" = 4 bytes. 4 + 4 = 8 bytes
wc -m above.txt # "ABC" = 4 + "😄" = 1 byte. 4 + 1 = 5 bytes

Final Words

In this article, we covered the basics of using Vim, a powerful and flexible text editor. We started with how to open a file in Vim and then you learned about its modes. You also learned how to navigate through files, edit text, and use features like search and replace to save time. We also explored a helpful summarization tool.

If you're new to Linux and want to build a strong foundation, check my previous article where I cover the basics of Linux, including essential commands and tips for beginners. It’s a perfect starting point to complement what you’ve learned about Vim here!

Keep practising these commands, and soon they'll become second nature to you. Mastery comes with repetition, so continue experimenting and applying these fundamentals in real-world scenarios.

Stay tuned for more articles. Get ready to take your RHEL skills to the next level.

Let’s connect!

We just published a course on the freeCodeCamp.org YouTube channel that will help you master the VIM editor. Whether you're new to VIM or looking to deepen your understanding, this course will equip you with the essential skills to leverage VIM effectively in your development workflow. Andrew Brown from ExamPro developed this course.

By the end of this course, you will understand the historical context and evolution of VIM, gain proficiency in its core commands and modes, learn how to customize VIM to suit your personal workflow, explore advanced features, including plugins and scripting with VimScript, and develop the ability to integrate VIM into various development environments.

VIM is known for its steep learning curve, and it's not uncommon to hear about the frustrations of beginners. The initial challenges, however, give way to a powerful, efficient, and highly productive editing experience. This course aims to smooth your learning curve and transform your VIM experience from daunting to delightful.

Below you will find a description of the core sections in this course, starting with the Prelude and then covering core commands.

Prelude

PDP-7 and the Birth of Unix

To truly understand VIM, we need to start with the PDP-7, a minicomputer from the 1960s where the Unix operating system was born. The development of Unix led to the creation of various text editors that served as precursors to VIM. Unix introduced a host of command-line tools foundational to modern computing, and emulating Unix 1 allows us to appreciate the environment in which early text editors like Ed and Ex were developed.

What is Ed and EX?

Ed is one of the earliest text editors for Unix, known for its simplicity and command-based interface. Engaging with Ed directly helps us understand its command structure and functionality, laying the groundwork for subsequent editors.

Ex, on the other hand, extended Ed's capabilities, adding more features and improving user interaction. Following along with Ex, we can experience its enhancements and see how it set the stage for Vi, the next evolution in text editing.

What is VI?

Vi, or visual editor, was a significant leap forward, offering a screen-oriented approach to text editing. Exploring Vi's interface and basic commands reveals why it became so popular among developers.

Vi was further improved into VIM (Vi IMproved), which builds upon Vi with extensive enhancements, making it a powerful editor for modern development. Starting with Vimtutor, an interactive tutorial, and exploring the built-in help system is an excellent way to get acquainted with VIM.

Evolution and Versions of VIM

Understanding the different versions of VIM and their evolution over time is crucial for appreciating its current capabilities. Experimenting with various VIM versions allows us to appreciate their differences and how VIM has adapted to meet the needs of developers.

Additionally, learning to install and use GVim, the graphical version of VIM, offers a more accessible introduction for new users.

Customization and Plugins

Discovering VimScript, the scripting language used to extend VIM's functionality, enables you to automate tasks and create custom commands.

Diving into VIM's configuration files, we learn to personalize our editing environment. Using plugin managers, we can extend VIM's capabilities with community-developed plugins.

Janus, a popular VIM distribution that comes pre-configured with a suite of plugins and settings, offers a streamlined setup. Installing and experimenting with Janus, and learning to use Vim Plug, a minimalist plugin manager, helps us manage VIM plugins efficiently.

NeoVIM, a modern refactor of VIM designed to improve performance and extendibility, offers enhanced features and improved user experience. Exploring NeoVIM and its capabilities further enhances our understanding of VIM's versatility.

Finally, Vimium, a browser extension that brings VIM-style navigation to the web, showcases the influence of VIM's keybindings beyond traditional text editing.

VIM Core Commands

Integration with IDEs

Learning how VIM can be integrated into other Integrated Development Environments (IDEs) combines VIM's efficiency with the features of modern IDEs. Installing VIM extensions in popular IDEs like Visual Studio Code allows us to use VIM's editing capabilities within a familiar environment.

Basic Navigation and Editing

Mastering the home row keys, which are central to VIM's command structure, increases our editing speed and efficiency. VIM operates in different modes, each designed for specific types of tasks, and understanding and switching between these modes is crucial for effective use. Practicing normal, insert, visual, and command-line modes helps us become comfortable with VIM's modal nature.

File and Motion Commands

Learning commands for opening, saving, and closing files is essential for managing our work in VIM. Motion commands allow us to navigate text efficiently, with directional motions (h, j, k, l) being the basic movements used to navigate text.

Practicing using directional motion commands to move through text quickly, as well as learning goto motions for jumping to specific locations within the file, enhances our text navigation skills.

Word motions allow for navigation by words, making it easier to move through text, and joining lines of text seamlessly is a useful command for text formatting.

Commands to quickly navigate to the start or end of a line, the replace command for quick substitutions of text, and undo and redo commands for managing changes effectively are all part of our core VIM toolkit.

Advanced Editing

The change command allows us to replace portions of text efficiently, while the delete command helps us remove text quickly.

Yanking (copying) and pasting text are fundamental operations in VIM, and learning insert and append commands allows us to add text in different ways.

The line insert command for inserting lines of text efficiently, the find command for locating specific text quickly, and the substitute command for replacing text patterns are all advanced editing techniques that increase our efficiency.

The leader key is a customizable shortcut that simplifies complex command sequences, and mastering visual mode for text selection and manipulation is essential for effective editing.

Indentation commands help us format code and text properly, and window splitting allows us to work with multiple files or views simultaneously.

Understanding buffers for managing multiple open files, and registers for storing and retrieving text snippets for reuse, rounds out our advanced editing capabilities.

Conclusion

By the end of this course, you'll have a solid foundation in VIM, enabling you to use it effectively in your development work. Watch the full course on the freeCodeCamp.org YouTube channel (4-hour watch).

In this article, we'll explore the most common Vim key bindings that will help you navigate your text editor seamlessly.

Table of Content

• Vim Modes
• How to Navigate using Vim Key Bindings
• How to Edit Text in Normal Mode
• Insert Mode
• Visual Mode
• More Navigation Commands
• Programming Specific Key Bindings
• Conclusion

Vim Modes

Vim operates in distinct modes, each designed for specific tasks:

• Normal Mode: Default state for efficient movement, deletion, searching, and more.
• Insert Mode: Allows you to type text directly into your file.
• Visual Mode: Enables text selection for manipulation.

How to Navigate using Vim Key Bindings

Basic Movement

Here are some basic movement keys:

h  --> move left
j  --> move down
k  --> move up
l  --> move right

Moving to Top and Bottom

You can use these keys to move to the top or bottom of the page:

gg  --> Move to the first line of the page
G   --> Move to the last line of the page

Moving to a Specific Line

You can move to a specific using : followed by the line number:

:number   --> Go to the line number

Moving Within a Line

You can use these keys move to the start or end of a line:

$  --> Go to the end of the line
0  --> Go to the start of the line

Moving Through Words

Here are some keys for moving through lines of text:

b  --> Go to the previous word
w  --> Go to the next word

How to Edit Text in Normal Mode

Deletion and Copying

You can delete or copy characters using these keys:

x   --> Delete the character under the cursor
dd  --> Delete the entire line
yy  --> Copy (yank) the entire line
p   --> Paste the previously deleted or copied text after the cursor

Undo and Redo

u          --> Undo the last action
Ctrl + r   --> Redo the undone action

Searching and Replacing

/              --> Start searching forward
?              --> Start searching backward
:s/old/new/g   --> Replace all occurrences of "old" with "new" in the entire file

Insert Mode

In Insert mode, you can type text directly into your file. Here are some key bindings to help you navigate in this mode:

Esc   --> Return to Normal Mode
i     --> Start inserting text before the cursor
a     --> Start inserting text after the cursor
o     --> Open a new line below the current line and start inserting text

Visual Mode

Visual mode is useful for selecting and manipulating text visually. Here are some key bindings:

v          --> Start character-wise visual mode
V          --> Start line-wise visual mode
Ctrl + v   --> Start block-wise visual mode
d          --> Delete the selected text
y          --> Copy (yank) the selected text
p          --> Paste the copied text after the cursor

More Navigation Commands

Scrolling

Ctrl + u   --> Move half a screen up
Ctrl + d   --> Move half a screen down
Ctrl + b   --> Move one full screen up
Ctrl + f   --> Move one full screen down

Jumping between Words and Paragraphs

(  --> Jump to the beginning of the previous sentence
)  --> Jump to the beginning of the next sentence
{  --> Jump to the beginning of the previous paragraph
}  --> Jump to the beginning of the next paragraph

These commands provide a comprehensive overview of the essential Vim key bindings for efficient navigation and text manipulation.

Programming-Specific Vim Key Bindings

Moving Between Functions

In a code file, navigating between functions is a common task. Vim makes it efficient with these keys:

]]  --> Move to the beginning of the next function
[[  --> Move to the beginning of the previous function

These commands are invaluable for quickly jumping between different parts of your code.

Indentation

Maintaining consistent code indentation is crucial. Vim enhances this with these keys:

>>  --> Indent the current line to the right
<<  --> Indent the current line to the left

Effortlessly adjust the indentation to adhere to coding standards and improve code readability.

Folding

Code folding aids in managing large files. Vim provides powerful folding commands:

zf{motion}  --> Create a fold (replace {motion} with a movement command)
zo          --> Open a fold
zc          --> Close a fold
zr          --> Reduce folding level throughout the file
zm          --> Increase folding level throughout the file

Use folding to collapse and expand sections, this makes it easier to focus on specific parts of your code.

Code Commenting

Efficiently comment and uncomment code with:

gcc  --> Comment/uncomment the current line
gc{motion}  --> Comment/uncomment the lines covered by {motion}

Speed up the commenting process and maintain code documentation effortlessly.

Matching Parentheses

Effortlessly navigate and understand code structure with:

%  --> Move to the matching parenthesis, bracket, or brace

This makes it easier to navigate complex code by quickly jumping between corresponding code blocks.

Conclusion

In essence, mastering Vim key bindings unlocks a world of efficient text editing. From basic movements to advanced coding tasks, Vim's modes and commands streamline navigation and manipulation.

By embracing these key bindings, you'll enhance productivity and enjoy a more seamless editing experience. Happy coding in Vim!

If you have any feedback, then you can DM me on Twitter or LinkedIn.

I was hitting my limits. Everything I was doing I did decently fast, but I didn’t get any faster.

I've since learned that Vim is the only editor that you get faster using with time.

Vim is based solely on shortcuts. When I discovered that and played around a bit, I felt numb and a little stupid, having not learned the shortcuts (called Vim language) much earlier in my career.

I realized there was a keystroke to get to any specific position I wanted to jump. It was like a game, seeing if I could use fewer shortcuts to accomplish a particular edit. It’s where many Vim users get a lot of pleasure from coding and writing. It felt liberating, moving my cursor with the precision of a surgeon.

Although speed is a smaller benefit, it got me started when I saw others navigating in Vim. After climbing the steep learning curve, it’s still one of the most powerful skills I've ever learned in my career, working for a living on a computer.

Let’s debunk the myth of Vim and learn how it’s possible to remember all the shortcuts using the specific Vim language. We'll see how to move with vim motions, and I'll share what I’ve learned so far, and why you might give Vim a try as well.

Learning the Vim Language

Lots of things have been said about Vim – how fast it is, how only Linux nerds use it, and that it’s impossible to exit Vim.

For myself, I fell in love with the “Vim language”. You see, I’m bad at remembering anything and thought that Vim was not for me. But this wasn't the case for one specific reason: Vim motions and its language.

I learned that there’s a grammar behind the editor. With it, you express what you want to do first, how many times, and then what you want it to apply.

Let’s get deeper into Vim and the language behind it.

How the Vim Language and Motions Work

Vim has a terrific language or grammar behind its shortcuts. Instead of remembering a thousand shortcuts, you can learn a couple and combine them.

These are often called the Vim language or Vim motions for moving around. This has nothing to do with the editor yet – these are universal and available in other editors as well.

For example, there's VSVim for VSCode, IdeaVim for the JetBrains products, Vintage Mode for Sublime, and so on. But there are also Browser extensions like Vimium or Firenvim, and Gmail even adapted some of Vim's shortcuts for navigation (j, k for moving, g for jumping).

Everyone who types on a computer eight hours a day should learn the Vim language. Yes, it’s hard in the beginning, but that’s the case with everything new and different. But getting better every day and having more fun coding or writing should be motivation enough. You're not too busy to learn - you'll learn as you go.

Vim Grammar

Just as spoken language grammar has verbs, subjects, and objects, so does the Vim language. The grammar has different verbs to begin with. Copying (or yanking) in Vim with y, deleting with d, pasting with p, changing with c, and so on.

For example, the easiest shortcut is copying a line with yy. In this case, yank is the verb and the second y is a synonym for y_. The y is doubled up which makes it easier to type since it's a joint operation.

Next, we can add movements. Each verb takes a subject for their movements. There are lots of movements (more in the next section) – the easiest is with numbers.

For example, to copy three lines, you add a 3 in front, such as 3yy. You can do that with all verbs, like deleting three lines is 3dd. Another would be { and } to move to the beginning or end of the paragraph, respectively.

In addition to verbs and subjects, the Vim language also has objects. For example, we can save text into different clipboards (called a register in Vim) with "ay. Here, we copy it into register a, which would be the object. We can paste it again by doing the same but using the verb paste instead of yank "ap.

There are even adjectives and adverbs with prefixes. Usually, you use a verb and an object. But instead of going down three lines with 3J, which joins the following three lines, you could add d5}, which means “delete from the current line through the end of the fifth paragraph down from here.”

For me, the most magical thing about Vim is how you navigate and edit text – and it still has nothing to do with the editor.

Sure Vim was the one that introduced and perfected these actions, but again – you can get them anywhere else. This goes deep into the Vim language, yet we still need to touch on the editor. This is important to know.

I hope you've started seeing the power of such patterns, though. With a couple of verbs and objects, you can already know hundreds of combinations without memorizing each one individually.

You can watch a video on Mastering the Vim Language or read a full exposition of the Vim language on this terrific StackOverflow comment.

Vim Motions

Vim motions are how you navigate, whether you navigate to the end of the word or back to the start of the document – these are all motions.

These are the first things you start learning (and hating) when learning Vim. They're extra hard to figure out initially, but they're something you'll want to use everywhere when you get used to them.

Instead of using arrow keys, Vim uses jk to move down and up and hl to move left and right. The main idea is to use the keys your right hand naturally rests on. You do not need to move your hands or even fingers for navigation.

Again, this seems like a small thing, but once you've learned it, you know why everyone is telling you about it.

Some common motions are:

h,j,k,l - left, down, up, right
w,W - to start of next word or WORD
b,B - to start of previous word or WORD
e,E - to end of word or WORD
$   - to end of line
^   - to start of line

You can find the most important motions to start with in this cheatsheet:

This Vim Command Cheat Sheet is from Cloud Guru.

How to Use Vim Modes (normal, insert, visual, and command)

Modes are another thing that might get you confused at the beginning.

When you launch Vim, you are not typing what you click on your keyboard as you are not in the “insert” mode that you're likely familiar with from other editors. Instead, the normal mode you are in lets you do the commands explained in the above Vim language and motions.

Vim is the only editor that optimizes editing text instead of writing from a blank page.

That’s another reason Vim makes you so efficient: you have different modes for each phase of your current work or task.

• Normal mode is for reading code and navigating quickly.

• Insert mode is for when you want to add some code or text.

• Visual mode is unique, the same as highlighting text with the mouse, but with the above Vim motions.

• And command mode is the powerhouse, where you can type Linux commands such as formatting a JSON file with :%!jq (whereas jq is a command line tool installed on your machine) and execute them within Vim. This is also where you can use Vim commands such as :sort for sorting your files.

I could go on here, but I want to dive into the editor itself now and explore why I learned it initially and how to get started.

Introduction to Vim the Editor (Neovim, Lunarvim, and Helix)

So what is Vim the editor, then? It started with the simple vi editor, a basic editor that implements the Vim language and can edit text. It's a little like Notepad++, which you might use on Windows, but without a mouse and context menu.

Vim is simply an improved version of Vi with more features.

Today there is even a newer version of Vim called Neovim. This version is super popular, and I’ve started using Neovim as well. Compared to Vim, Neovim uses Lua, an actual programming language, to configure and extend the editor. This makes writing plugins and configuring Neovim easier compared to Vim's native Vimscript.

Neovim is a great place to start learning Vim today, as it has so many awesome plugins. Neovim also won the most loved IDE on the StackOverflow survey a couple of times, last in 2022.

There is also an editor called Helix built in Rust, but it has minor deviations from the Vim language, which make it a less optimal place to start.

If you want to get started without needing to know anything about Neovim and spending hours on configurations, you can begin with LunarVim. It's a distro with all the features you know from VS Code already included.

Suppose you are comfortable with the terminal and realize you want to change the editor to your liking. In that case, you can kickstart your journey with a simple single-file configuration with many explanations that will work out of the box. You can also learn each config by opening the single config file.

Why I Learned Vim

Using the standard input method we use in our editors daily, we will eventually stagnate at a certain level. Sure, you can use cmd+arrow-keys (on a Mac) to jump to the beginning of a line or option+arrow-keys to jump between words instead of characters.

But what happens once you've mastered that? What if you need to change something in the middle of a sentence? There is no other way to jump several times with this option, or you move your hands away each time to reach the mouse to click on the exact spot.

One day, I saw a coworker work in Vim, and everything clicked. The Vim language and motions were the things I needed all along. So I installed the VS Code plugin, watched a couple of YouTube videos, and started my journey to learn the basic movements.

I also love learning new things and, even better, I'm always looking for ways to make me more productive 😉.

But as many of you might have experienced, the hardest part of learning Vim is getting started. The initial learning curve is very steep. Below is an illustration that shows this :).

It took me also two or three times trying to start learning Vim until I fully grasped it. I switched back and forth. As well as having to get work done, it is sometimes hard to switch entirely from one day to another. But I just loved learning all the movements, and I knew it would make me faster after a short time.

Why I Love Vim

I have been using Vim for only eight months, and coding with Python for around six years. I've been using other code editors since my career started in 2003. Each editor I used had its strengths and its appeal. But I never experienced such efficiency gains as I have with Vim.

In the end, use the editor that works best for you. Personally, I want my editor to help me work as fast as possible, especially since I use it daily. Investing a bunch of time learning Vim is necessary, but it pays off over time. That’s the whole point with Vim and especially the Vim language.

An underrated skill in general among programmers is using the terminal. By learning your editor, especially with Vim, you will naturally learn more about the terminal and improve your Linux skills (reverse search, lazy git, Tmux, and many more).

Before Vim, I only used the terminal if I had to. I googled everything, and today, I use the terminal with its helpful manuals whenever I can.

Sometimes I’m surprised by myself as well, and it’s super nerdy – but it’s so effective. I’ve become a much better developer since starting to get comfortable with Vim.

Tweaking and optimizing Vim can take hours and days, and it's unavoidable in the beginning. But after a while, your dotfiles mature, and you start changing things less. You will also get much faster at trying out a new plugin or adding a remap.

Also, Vim is fun! Working in Neovim is one of the highlights of my everyday work. Improving your text editor and making it your own – maybe in ways no one else has optimized – is awesome.

For example, I write a lot, so I optimized for writing markdown and programming in Python. That’s what adds a lot to my happiness as a coder.

Because of all this, TJ DeVries calls Neovim a PDE (Personalized Development Environment), not “just” an IDE. You can learn more about this in ThePrimeagen’s truly inspiring Vim videos and learn why he used Vim in 2022.

Vim also manifested minimalism more in me. I used the terminal instead of fancy GUIs and plain text files for clarity, freedom, blazingly fast shortcuts, no vendor lock-in, and staying in the Flow with the content in front.

Vim changed not only my workflow but how I was able to edit at the speed of thought. Instead of thinking, “I want to edit that word”, my fingers jump to that word and change it with a few keystrokes.

Vim for Data Engineering

My data engineering workflow uses Neovim with the LSP (Language Server Protocol) pyright installed with mason. There's much more with Tmux, but you can find all the details on dotfiles/nvim.

Vim for Writing

I’m still using Obsidian a lot more for writing (see more on my PKM workflow) due to its additional features of supported images, backlinks, graphs, and plugins specified for note-taking, such as ReadWise (syncing my highlight from books, and tweets), Dataview (using notes as a database), Excalidraw (drawing with Markdown format), Templates, and so on.

Nevertheless, I write more and more in Neovim. For now, I use ZenMode (for centering the text), Grammarly (for linting grammar), write-good (linting grammar), and specifically Obsidian.nvim (follow backlinks, and so on.). You find all details in my dotfiles.

In Obsidian, I use the Vim mode Obsidian .vimrc and map most hotkeys to my Vim settings. At the same time, I've been writing more and more in Neovim and have been progressively moving over to full Neovim.

Plugins such as Telescope and simple grep features that I use for coding work very well with Markdown. Here are some clips showing what is possible in an excellent talk about Writing, Editing, and World-Building at the speed of thought with Vim.

Why You Should Learn Vim, Too

When I heard about Vim, I thought that it was only for software engineers and Linux nerds 😅. I never thought I was going to use it as well. But how did I get into it?

I've already shared some reasons why I love Vim. But it really changed all my workflows, not only as a developer but also how I surf the internet, write, navigate, and use tools. I search for a Vim mode in any application I use.

But if you don't enjoy fiddling and optimizing your workflow, and if you don't write or code for a living, Vim might not be for you. Start with your current editor and activate the Vim mode before you do anything with Vim. It will save you a lot of frustration, trust me 😅.

How to Get Started Using Vim

There are many good resources that'll help you get started with Vim. The easiest is to type vimtutor into your terminal, which is an interactive tutorial for Vim.

I've already linked a few YouTube videos above – especially check out ThePrimagen starting with Vim As Your Editor or Why even bother with Vim or Neovim in 2022.

I started with Ben Awads’s Vim tutorial back then. An excellent Lecture: Editors (Vim) (2020). Mastering the Vim Language. I also collect a small playlist on YouTube with Vim content. A big inspiration also dev workflow using Tmux and Vim from Takuya.

Wrapping Up

We have learned that Vim is a powerful text editor popular among developers. It's based on shortcuts, called the Vim language, which can make coding and writing faster and more efficient.

With Vim, you can jump to any specific text position and rapidly make precise edits. While learning Vim can be challenging, it is well worth the effort in the long run as it will improve your productivity and bring joy to your coding experience.

If you want to go further, try Tmux, which plays well with Vim. You could even go one level deeper, which is a dedicated keyboard layout such as Dvorak or Halmak (which I started learning at some point). Or buy a fancy ergonomic keyboard or build one yourself.

Thanks for reading this far. I hope you enjoyed this article. I'm looking forward to hearing your comments and experiences.

You can read more of my other tutorials at www.sspaeti.com.

In this article, you'll learn a lot about Vim and see how you can quickly start using Vim as a developer.

What is Vim?

Vim is an acronym for Vi IMproved. It is a free and open-source cross-platform text editor. It was first released by Bram Moolenaar in 1991 for UNIX variants.

Vim is based on the original Vi editor, which was created by Bill Joy in 1976. In the 90’s, it started becoming clear that Vi was lacking in some features when compared with the Emacs editor. So Bram implemented many missing features and released it under the name Vim.

How to Install Vim

Vim runs across various platforms such as Windows, Linux, and Mac.

To install Vim on Windows, download the executable file from the Vim site and run the file. Follow the instructions shown on the screen and you'll be good to go.

Vim comes pre-installed on most *nix operating systems. But if it's not installed on your system, you can install it with a package manager of your choice.

Here's the installation command for Debian-based operating systems:

sudo apt-get update
sudo apt-get install vim

To ensure that it's installed properly, run which vim and you should get /usr/bin/vim in your output.

How to Get Started with Vim

You can get started with Vim by typing its name on the terminal like this:

Start Vim

Once you enter the above command, you'll be able to see a screen displaying info about Vim and some instruction to find help and exit Vim.

Vim Introduction

Vim Modes

You should be aware of the most important concept in Vim before moving on: modes in Vim.

Everything in Vim is considered a mode. You can achieve whatever you want if you understand modes in Vim. There are many modes in Vim. But, we'll be looking at the 4 most important modes.

They are:

1. Command Mode
2. Command-Line Mode
3. Insert Mode
4. Visual Mode

Let's explore them one by one.

What is Command Mode?

This is the default mode (also called Normal mode) in Vim. Whenever Vim starts, you'll be in this mode. You can switch to any mode from this mode. You can't do this in any other modes.

Basically, to switch from one mode to another, you have to come to Command Mode first and then navigate to the other mode. The commands that you run without any prefix (colon) indicate that you're running the command in command mode.

What is Insert Mode?

This mode is used to edit the contents of the file. You can switch to insert mode by pressing i from command mode. You can use the Esc key to switch back to command mode.

What is Command Line Mode?

You can use this mode to play around with some commands. But the commands in this mode are prefixed with a colon (:). You can switch to this mode by pressing : (colon) in command mode.

What is Visual Mode?

You use this mode to visually select some text and run commands over that section of code. You can switch to this mode by pressing v from the command mode.

The above 4 modes are enough to perform a basic set of file operations in Vim.

Ok the theory is done. Let's explore Vim practically.

Common Text Editor Operations in Vim

How to Create a New File

Creating a new file with Vim is simple. You can do it from command line mode.

Run the following command to create a new file:

:edit sample.txt

The above command opens a sample.txt file in edit mode if it exists, and creates a new file otherwise.

Create a new file with the name sample.txt

After running that command, you'll be in command mode (as shown in the below screenshot), and you'll not be able to enter any text:

Command mode showing new file created

To add some text to the created file, press i in the keyboard. You use the i command to enter some text in the file. Once you press i, you'll be able to see that you entered Insert mode in Vim by looking at the bottom left of the file.

Insert mode in sample.txt file in Vim

In this mode, you can type whatever you want into the file.

Added some content in sample.txt file

We're done with writing our content. And now we'll want to save the file. If you do not save and just close the terminal at this point, all your content will be lost.

How to Save a File

To save a file, you have to switch from Insert mode to Command Line mode. Remember I told you earlier – whenever you want to switch from one mode to another, you have to first switch to Command mode and then you can easily switch to whatever mode you want.

To switch to Command mode from Insert mode, you have to press the Esc key.

After you press the Esc key, you'll not be able to see the --INSERT-- at the bottom left. This indicates that you're not in Insert mode anymore and you're now in Command mode.

Command mode in sample.txt file

To save the file, type the following command:

:w

Command to save the file

How to Close a File and Exit Vim

Once you save the file, you can close Vim by closing the terminal. But, the proper way to close the file and the Vim editor is by using the following command:

:q

Close the file and vim editor

The above command closes the file and quits the vim editor.

Alternatively, you can use a command that's the combination of the above 2 commands (save & quit) to quickly save and quit Vim. The command is:

:wq

The above command quits the Vim editor immediately after saving the file.

How to Edit a File in Vim

To edit a file, you have to open the file using Vim and switch to Insert mode.

Let's open the sample.txt file we created above:

vim sample.txt

Open sample.txt file using Vim

We are in Command mode now. To edit the file, we have to switch to Insert mode. As we saw earlier, pressing i from the Command mode will switch to Insert mode.

Switch to Insert mode by pressing i

Follow the same procedure for saving the file and quitting Vim. Press Esc on the keyboard and type :w to save the file and :q to quit Vim.

You may wonder, though, what if I want to close the file without saving my changes? (Ignore the changes I made and bring the file back to the old state).

How to close the file without saving the changes

To close the file without saving the changes, you have to run :q! from Command mode.

Let's explore this with an example:

Content in sample.txt file

I've added some more content to the file.

Added some content in sample.txt file

But, I don't want to save the changes I made now. To close the file without saving this change, we have to switch to Command mode (by pressing the Esc key). Type :q! in the Command mode. This will close the file ignoring the changes made.

Ignore saving the sample.txt file

Let's view the file and confirm if we get the expected output:

View sample.txt file

Yeah. The file does not have the last line which we added recently. So, the changes were not saved.

How to Cut, Copy, and Paste Text from a File using Vim

You can Cut, Copy, and Paste in 2 ways in Vim. They are:

1. Using Visual mode
2. Using keyboard

Out of these two ways, Visual mode is simpler to understand. Since this is a beginner-friendly guide, let's explore how to cut, copy, and paste in Visual mode.

Let's open the file in command mode before we proceed:

sample.txt file opened in command mode in Vim

Let's assume you want to copy the word "Hello" from the 1st line and paste it into the 3rd line.

The first step is to place your cursor in the place from where you want to copy the text (being in command mode).

Moved the cursor to the beginning of the word Hello

Enter Visual mode by pressing the v key on the keyboard.

Enter Visual mode

The -- VISUAL –- text at the bottom left indicates that we're in visual mode.

Move the cursor to the place where the text you want to copy ends.

In this case, I'm moving the cursor to the letter o of the word Hello.

While you move your cursor, Visual mode highlights the text from the beginning up to your cursor.

Highlighted text in Visual mode

Once you're done moving your cursor to the right place, hit y to copy the text or hit d to cut the text.

In this case, I'm copying the text. So, I press y on my keyboard.

Move the cursor to the place where you want to paste the text.

Move the cursor to the place where you want to paste the text

In our case, we have to move the cursor to the 3rd line.

Press p (in lowercase) to paste the text after the cursor and P (in uppercase) to paste the text before the cursor.

Hello text pasted on 3rd line

Press :wq to save and close the file

How to Find and Replace Text in Vim

Finding text and replacing it with some other text is simple and straightforward in Vim. There's a one-line command that simplifies this entire process.

Here's the syntax:

:[range]s/{pattern}/{string}/[flags]

Let's dismantle each part and understand how it all works.

• [range] indicates that you can pass the range of lines. Pass % to find and replace in all lines. The range is separated by a comma. To find and replace between lines 5 to 10, pass 5,10. Use . to represent the current line and $ the last line of the file.
• {pattern} indicates the pattern to find the text. You can pass regex patterns here.
• {string} is the string to replace in the found text.
• [flags] indicates if you wish to pass any additional flags (for example, the flag c is passed to confirm before replacing the text). By default, this does a case-sensitive search. You can change it to do a case-insensitive search by passing a i flag.

Alright, let's explore this with an example.

sample.txt file content

Our sample.txt file has 2 "Hello"s. Let's replace "Hello" with "Hi" at both places.

The command to do that is:

:%s/Hello/Hi/g

• %s indicates replacing the content in the entire file
• Hello is the search text
• Hi is the text to replace
• g indicates making the change globally

While running the command to change "Hello" with "Hi"

After running the command

Let's understand this with another example.

This time, I want to change the word "Hi" (case-insensitive search) that occurs between lines 2 and 3 and replace it with "Hello and Welcome", with a confirmation to change each occurrence.

The command to do that is:

:2,3s/Hi/Hello and Welcome/gci

Running the command to change the text from line 2 to line 3

Asking for confirmation to change the occurrence

Here's a description for each option:

• y - Replace the match
• n - Skip the match
• a - Substitutes the match and all remaining occurrences of the match
• q or Esc - Quit substitution
• l - Replace the match and quit
• CTRL+Y - Scroll the screen down
• CTRL+E - Scroll the screen up

I want to accept the change. So, I press y. Here's the output after pressing y.

After replacing the word

Since we have only one occurrence of "Hi" between lines 2 and 3, it did not ask for any further confirmation and the operation is complete.

How to Undo or Redo in Vim

To undo a change in Vim, press u in command mode. To redo, press CTRL + R. You can prepend a number (n) with u to undo n times. for example, 2u will undo 2 times. To list the available undo options, type :undolist in command mode.

Let's understand this with an example.

Here's the current state of our sample.txt file:

Current state of sample.txt file

I have my cursor at "a" in the "Hello and Welcome" text on 3rd line. Let's remove the word "and" by typing dw on command mode:

Removed the word and by typing dw in command mode

Let's undo to bring the word "and" back into the file. To do so, press u in command mode.

Changes are undone after typing u in command mode

Let's redo and take away the word "and" by typing CTRL + R in command mode.

Changes were applied again on redo by pressing CTRL + R in command mode

Conclusion

In this article, you have learned the basics of Vim. This article should be enough to get you going and do some basic file read/write operations with Vim.

Just keep in mind that I've not even covered 1% of Vim. But I'm sure these basics will help you explore Vim quickly and confidently.

To learn more about Vim, subscribe to my email newsletter at my site and follow me on social media.

When you compare them manually, you might make a mistake, and it's easy to miss minute changes. Apart from that, finding changes in large files can be exhausting.

There are many online tools and text editors that help you efficiently compare files. But there is an easier, hassle-free method to compare files using the Linux command line.

The Linux command line is very powerful and provides a file comparison utility within vim to differentiate files side by side.

Learning file comparison in the command line is helpful because many servers use only a CLI (Command Line Interface). This means that you don't have the luxury of a GUI where you can run the browser or other text editors.

What is vimdiff?

Vimdiff is a Linux command that can edit two, three, or four versions of a file with Vim and show their differences.

Vimdiff syntax

For comparing two files, the syntax is the following:

 vimdiff [options] file1 file2

Let's compare two files index.js and index.js.bkp to see their differences.

vimdiff index.js index.js.bkp

Output:

Vimdiff output

Here we can see the difference in the highlighted line.

To make things easier, we can show the line number as well. When you are in Vim, go to the extended command mode by pressing escape twice and typing :set number. This will reveal the line numbers for the current session.

Line numbers in vim

Let's have a closer look at the output again:

Detailed output of vimdiff.

• Uncollapsed lines: These are the lines of codes that have not been changed. these are wrapped and can be uncollapsed using a combination of the z+c and z+o keys.
• Highlighted changes: These are the differences present in a file.
• Line numbers: These are the corresponding line numbers in files.
• File names: The file name on the left is the first filename mentioned in the command. The file name on the right is the second filename provided in the command.

There is also a way to enable line numbers in Vim by default so you don't have to set it manually each time.

How to show line numbers by default in Vim on Linux

If you like to view line numbers by default in Vim, you can follow these steps:

1. Locate the vimrc file.

Vim configurations are present in the vimrc file. The file location might vary from one Linux distribution to the other. In Ubuntu, the vimrc file is located in /usr/share/vim/.

2. Edit the vimrc file.

Simply append set number in the file and save and exit.

Now whenever you open Vim, the line numbers will be there by default.

Vimdiff Operations

Let's see how we can utilize the powers of vimdiff.

First, make sure you are in the command mode.

You can go into the command mode by pressing the escape key twice.

How to split screens horizontally

By default, vimdiff splits the screen vertically. If you like to see the files split horizontally, you can use the flag -o like this:

vimdiff -o index.js index.js.bkp

Output:

Horizontal split

How to navigate in diff window

• Navigate between diff windows

To navigate between panes, use a key combination of Ctrl+W+W. The cursor will switch between the files once you press the keys.

• Jump to changes

Instead of scrolling down line by line and scanning for the changes, you can jump to the change with a specific key combination.

1. To move to the previous change use: [ + c.
2. To move to the previous change use: ] + c

How to apply changes from diff window

• To apply changes from the left file to the right file:

To apply the changes from the left file to the right file, first, move to the highlighted change. Then, use the command:

:diffput

Remember that you'll need to be in the command mode.

Using diffput to apply changes from left to right.

• To apply changes from the right file to the left file:

To apply the changes from the right file to the left file, first, move to the highlighted change. Then, use the command:

:diffget

Using diffget to apply changes from right to left.

How to undo changes

If you make a mistake, you can undo the changes provided you didn't save the file.

When you are in the command mode press u to undo the last change.

If you've recently undone a change, you won't be able to see the highlighted changes as before. You'll need to refresh to see the changes once again. You can do this by using the command:

:diffupdate

How to open and close folds

The unchanged lines are wrapped to provide better readability.

To view the uncollapsed lines as shown above, move the cursor there and use the following key combinations:

• To open the folds: z + o.
• To close the folds: z + c.

How to exit the diff window

There are many ways to exit the diff window depending on the end result.

• :qa to exit all the files without saving.
• :q to exit the files one by one without saving.
• :wq! to save and exit files one by one.

Conclusion

Comparing files is easy and fast with vimdiff as we compare files within the command line. In this tutorial, you learned how to use the vimdiff command to efficiently find differences in code or configuration files.

I hope you found this tutorial helpful. Thank you for reading till the end.

What’s your favorite thing you learned from this tutorial? Let me know on Twitter!

You can also read my other posts here.

_{Image credits: Programming vector created by storyset - www.freepik.com}

We just published a full Vim course on the freeCodeCamp.org YouTube channel that will teach you how to use Vim.

Florian Dedov from NeuralNine developed this course.

When someone masters Vim, they can often be more efficient with it than using other text editors. Vim forces you to use only the keyboard and no mouse. This limits the time you waste moving your hand between devices.

Another great thing about Vim is that it can be installed anywhere and comes preinstalled on many machines. If you need to SSH into a Linux box, Vim is often one of the only text editors available.

In this course you will learn how to use all the most common Vim commands and some common Vim extensions. You will even learn how to exit Vim.

Watch the full course below or on the freeCodeCamp.org YouTube channel (1-hour watch).

When you're coding, you're writing various text that can be executed by different language compilers. And what makes this text fun and easy to write are the editors that we use.

Different editors have different features. But they have a common goal: making writing code easier – easier to compose, debug, and read.

In this article, we'll look at five code editors that can improve development on your Mac device.

1. Sublime Text

Sublime Text is a lightweight editor with many features for improving your code-writing experience. Here are some of its features:

Multiple view panes

Multiple view panes

Sublime Text offers multiple view panes for writing code. This way, you can view multiple files at once.

What's more fun is you can open the same file in two panes. This feature can be helpful when you're writing code in a file with long lines of code, as you'll be able to scroll to the top in one pane and then write in the bottom of the other.

Side-by-side view for Type Definitions

Instead of just viewing type definitions in a small popup or opening the definition file that overrides the current view, Sublime Text provides a side-by-side view of a definition file for the types in the current file.

Multiple Selections

Multi-Line Selection Text Entry with Sublime Text

There are two forms of multi-selections: multi-selecting the same characters or different characters.

Same character selection

Say you want to rename a literal (variable, function, and so on) in multiple places. Sublime Text allows you to highlight the literal, and using Ctrl/Cmd D you can select other occurrences of that literal and edit, replace, or do what you want.

Different characters selection

Maybe some literals are spelled differently, but you want to highlight them together. Sublime allows you to use your mouse to highlight many things at once and operate on them as you choose.

2. VSCode

The VSCode editor offers syntax light, IntelliSense features (autocompletes, code hinting, and more), custom configurations, and room for different plugins. VSCode also allows multiple selections and multiple view panes.

Here are more features of VSCode:

Code Debugging

With VSCode, you do not need to debug on your browser or other tools.

Debugging in Visual Studio Code

VSCode allows you to debug right from your editor using breakpoints, the call stack, and even an interactive console.

Many extensions for different things

VSCode has a large marketplace for different languages, frameworks, and even your editor. You have extensions that beautify your editor's appearance and experience and tools that help with autocompletion when writing code.

Managing Extensions in Visual Studio Code

Built-in Terminal

With VSCode, you have a a built-in shell terminal where you can execute commands without leaving your editor to go to a different terminal app.

The terminal view of VSCode

A small screen may make your editing view small and a bit inconvenient, but with a large monitor, for example, the view is just okay.

VSCode also has multiple view panes, character selection, and multiple character replacements.

3. Atom

Atom is a highly customizable code editor. This is why the team calls it a "hackable text editor". From the appearance and colors on the editor to the key combinations for commands and many other things, you can customize Atom as much as you wish and make it very personalized.

Here are some features:

Real-time Code Collaboration

Teletype for Atom

Atom has a Teletyping feature that allows multiple people to work on a codebase in real-time. This feature improves collaboration in a team workspace on projects. For VSCode, you'll usually need an extension for this.

Git Integration

With Atom, you never have to go to your terminal for your Git operations.

GitHub for Atom

Git actions are integrated into Atom using the GitHub package, and this creates a smooth version control experience while you write code.

Smart Autocompletion

With many languages and syntaxes integrated into Atom, you also get a nice auto-completion feature while writing code.

Autocomplete (atom.io)

You don't have to type out those long method and variable names anymore. Atom's smart enough to help you avoid that 😉.

In Atom, you also have search and replace features, view panes, and more.

4. WebStorm

WebStorm calls itself "The Smartest JavaScript IDE". It takes a lot of confidence to call itself that, and WebStorm actually delivers. WebStorm makes writing JavaScript and its related technologies not just convenient but more enjoyable.

Some features include:

Built-in developer tools

WebStorm takes the name "development editor" quite literally. From running scripts to breakpoints and general debugging, WebStorm provides developer tools that allow you to write, execute and debug your code.

WebStorm: Integrated Developer Tools

Smart features

This editor allows you to move files between folders seamlessly. It also helps you refactor your code and suggest fixes for errors.

And the most brilliant feature I love about it is that you can easily rename a specific variable across your application. Say you have a variable you've imported in many files – you can easily rename that variable from one of the files.

Fast search and navigation

Another fantastic feature of WebStorm, which people generally praise it for, is the fast file or folder search and navigation.

WebStorm: Navigation and Search

From searching file names, class names, function names within files, and special selectors, you can easily find a file you're looking for.

There's also collaboration, view panes, search and replace in WebStorm.

5. Vim

And there's Vim. It's worth noting that Vim is not for everyone, as it arguably has a steep learning curve – but Vim has many features that make it worth trying out. I have a friend who's never letting go of Vim and keeps advocating that people are missing out.

Here are some features:

High Customizability

I mentioned earlier that Atom is highly customizable, but I don't think it's as flexible as Vim.

Vim customized to be like SublimeText

Down to the low-level commands and feel of the editor, you can configure many things that makes using another editor very strange for you. You can also create scripts that automate things for you.

Support for Many Languages and File Formats

Vim has support for many languages and files of different kinds. It also integrates with many tools.

Powerful search feature

With powerful selectors and regex, you can do multi-level file searches and replacements. With Vim's scripts, you can also get plugins that take the search features to another level.

Agreed, it's not very easy to learn. But it's pretty powerful and consumes less memory, surprisingly. It also has an extensive script system that gives you much power while writing code.

Wrapping Up

There you have it - five code editors you can use to write cleaner, more readable code. I hope you find the one that best fits your needs!

Thanks for reading :)

I've been using Vim since the first year I started coding. For all the IDEs/editors that I have used, the Vim plugin is always the very first plugin that I install.

I know that Vim can be challenging to work in for people who are not familiar with it. In this article, we'll cover some fundamental topics like how to exit Vim, rather than quitting Vim.

I will also include the command that you can use to reveal the corresponding help documentation. To do that, first we need to press ESC a few times, and run the command provided, for example, :h vim-modes, and press Enter.

TL;DR – How to Exit Vim

1. Press ESC once (sometimes twice)
2. Make sure you are using the English input method
3. The next step depends on the current status and your expectations:
   • If you didn't make any changes, type :q and press Enter/return
   • If you made some changes and would like to keep them, type :wq and press Enter/return
   • If you made some changes and would rather discard them, type :q! and press Enter/return

If you want to understand in more detail how this works, let's dive in.

What are Modes in Vim?

There are seven BASIC modes in Vim and seven additional modes that are considered variants of the BASIC modes. You may run :h vim-modes inside Vim to read the documentation if you would like to know more.

Fortunately, we don't have to know all of them in order to get started. But there are three modes that we need to be aware of: Normal Mode, Insert Mode, and Command-line Mode.

What is normal mode in Vim?

Normal Mode is crucial since it's only in Normal Mode that we can run commands (there are exceptions but those are beyond the scope of this article).

Say, if we want to read the documentation of vim-modes, then we have to first make sure we are in Normal Mode before typing in :h vim-modes. And the most canonical way of entering Normal Mode is by pressing ESC. Even if you are already in Normal Mode, pressing ESC will keep you in Normal Mode, so no worries.

Find it in the Documentation: :h Normal, :h mode-switching.

What is insert mode in Vim?

You use Insert Mode to edit the current file (in Vim, this is normally referred to as buffer). By default, we are in the Normal Mode right after we open a file. If we need to make changes to the current file, first we need to switch to Insert Mode.

The most common way to make this switch is by pressing i in Normal mode after navigating the cursor to the place that we are going to edit.

There are actually many other ways to enter Insert Mode as well, like o, O, a, A, I, and so on.

Find it in the Documentation: :h Insert, :h i_<Esc>, :h o, :h O, :h a, :h A, :h I.

What is command-line mode in Vim?

Command-line Mode is normally a "short-lived" mode, which you use to run "Ex commands" (not to be confused with the "commands" in Normal Mode).

Fun fact: Vim is actually a contraction of Vi Improved and it is based on another text editor named [vi](https://en.wikipedia.org/wiki/Vi). And vi is based on a line editor named [ex](https://en.wikipedia.org/wiki/Ex_(text_editor)). Both vi and ex were developed by Bill Joy.

Another fun fact for macOS users: there is only Vim on macOS and the command vi is symlinked to vim. Also note that the "Ex command" in Command-line Mode is different from the "command" in Normal Mode.

You can enter Command-line Mode by typing : in Normal Mode. For example, if you run the commands above to see the documentation, you are actually using the Command-line Mode as soon as you type in :.

Similarly, press ESC if you'd like to switch back to Normal Mode.

Find it in the Documentation: :h Command-line, :h cmdline-lines.

How to Exit Vim

documentation of :h quit

If you take a look at the documentation of :h quit, note that the quit is prefixed with :. This means that quit is used within Command-line Mode.

In order to enter Command-line Mode, first we need to make sure we are in Normal Mode, then simply type in :. Now that we are in Command-line Mode, just type in quit and press Enter or return.

You may also notice the :q there, which is actually the shorthand version of the :quit command. That being said, we can also quit Vim by executing :q .

It does mention, though, that this command will fail "when changes have been made and Vim refuses to abandon the current buffer" (if you still remember, buffer is just opened file(s), nothing fancy).

In this case, we'd need to use :wq, which means "write and quit". You can find this in the Documentation under :h :wq.

:x is another command that works almost the same as :wq. According to :h :x, it is "like :wq, but write only when changes have been made".

The difference here is that :wq will save the file no matter if you made changes to it or not. :x won't save the file if you didn't make any changes. What matters here is the modification time of a file, since :wq will update the modification time but :x will not.

There are some times that we'd rather not keep the changes that we've made. At this point, we need the :q! command. The ! is normally referred to as "bang", which makes q! something like "force quit".

Do note that if you use this way, you WILL lose all changes that you have made to this file and there is almost no way that you can recover them.

How to Troubleshoot Exiting Vim

What if I don't want to enter Command-line Mode?

Not a problem. In Normal Mode, you can also press ZZ or ZQ to quit Vim. Where ZZ is the same as :x and ZQ is the same as :q!.

Here, ZZ and ZQ are considered commands of Normal Mode while :x and :q! are Ex commands.

What if :wq failed?

This is legit since :wq could fail when the file is read-only or the file name is missing.

Note that when a file is read-only, Vim won't stop you from opening and editing the file. You may also find that :wq! won't work either at that moment. You might end up discarding all changes with :q! and open the same file prefixed with sudo and do the same changes one more time.

One thing you could do is to save this file in another directory that you have write permission to, like ~ or even /tmp. Then move it back to the directory where you don't have write permission.

In order to achieve this, you can run :w ~/my-backup-file which will save this file under ~. Next you can use the mv command to move this file around. Also note that this is what you need to do when Vim complains that the file name is missing.

There is another solution right inside Vim. You could run this command: :w !sudo tee %. Here !sudo means to run the sudo command in your shell environment.

For example, :ls will list all buffers in Vim but :!ls will run the ls command from the shell and display the result. tee copies from standard input (a.k.a. stdin) to standard output (a.k.a. stdout). % refers to the current filename.

This means that we use the sudo command from the shell environment, copy the content of the current file (note: modified version) from Vim, and redirect the modified content to the file (which is referred to by using the filename).

Warning of file content change

You will notice the warning above. This warning happens because the file content was updated within the shell environment without Vim's attention. So Vim considers this to be an external change and lets you know what happened.

You can just press Enter at this time since you made the external change on purpose.

You may also notice that the modified file content also shows up above the warning message. This is as expected since it comes from the stdout. If you don't want to see it, you may do :w !sudo tee% >/dev/null, which will discard the stdout from tee.

What if I am lost and have to force-quit?

Well if we try exiting by pressing control + c, Vim will show us the above info. But you may still get around this by Ctrl + Alt + Delete on Windows or Force Quit... on macOS.

Next time when you try to open the same file again, you should see this (here I am using a file named foo.txt as an example):

swap file

Don't panic – this is as expected, since Vim is trying to help you recover your valuable changes that you might have lost.

By checking the directory, you will find a file with the extension of .swp. This is a swap file (documentation: :h swap-file):

swap file .swp

We will see the following if we press R to recover:

.swp recover

After pressing Enter, now you'll notice that the changes you made earlier are back. And after you are done with the recover process, you can simply remove the .swp file so that you won't see the error above anymore.

Conclusion

In this article, we covered some fundamentals about Vim's modes and how to exit Vim. We also learned how to solve common issues when it comes to exiting Vim.

Thanks for reading. There is lot more to learn when it comes to Vim. But feel free to explore the Vim help documentation if you would like to learn more.

Configuring your .vimrc file lets you use the full power of Vim. With a customized .vimrc file you can increase your Vim powers tenfold.

In this article I will show you a few ways you can customize your .vimrc file.

I will go over:

• Basic Settings
• Plugins
• Folding
• Vimscript
• Status line

First create the following directory structure in your home directory.

.vim/
 ├── autoload/
 ├── backup/
 ├── colors/
 └── plugged/

$ mkdir -p ~/.vim ~/.vim/autoload ~/.vim/backup ~/.vim/colors ~/.vim/plugged

Create a .vimrc file in your home directory.

$ touch ~/.vimrc

How to Update Basic Settings in Vim

First let's add some basic settings that will improve your editing experience. I use double quote characters to comment out lines.

Add the following lines to your .vimrc file:

" Disable compatibility with vi which can cause unexpected issues.
set nocompatible

" Enable type file detection. Vim will be able to try to detect the type of file in use.
filetype on

" Enable plugins and load plugin for the detected file type.
filetype plugin on

" Load an indent file for the detected file type.
filetype indent on

Syntax highlighting is very useful. The next line we add will enable syntax highlighting and make your code easier to read.

" Turn syntax highlighting on.
syntax on

This is what it looks like before:

And after:

You can also choose to display line numbers to make navigating the file easier.

" Add numbers to each line on the left-hand side.
set number

You can pinpoint exactly where the cursor is located by highlighting the line it is on horizontally and vertically.

Add these lines to enable this feature.

" Highlight cursor line underneath the cursor horizontally.
set cursorline

" Highlight cursor line underneath the cursor vertically.
set cursorcolumn

Here are some more common setting that enhance the editing experience.
Each line contains a comment above it explaining what it does.

Add the following lines to the .vimrc file.

" Set shift width to 4 spaces.
set shiftwidth=4

" Set tab width to 4 columns.
set tabstop=4

" Use space characters instead of tabs.
set expandtab

" Do not save backup files.
set nobackup

" Do not let cursor scroll below or above N number of lines when scrolling.
set scrolloff=10

" Do not wrap lines. Allow long lines to extend as far as the line goes.
set nowrap

" While searching though a file incrementally highlight matching characters as you type.
set incsearch

" Ignore capital letters during search.
set ignorecase

" Override the ignorecase option if searching for capital letters.
" This will allow you to search specifically for capital letters.
set smartcase

" Show partial command you type in the last line of the screen.
set showcmd

" Show the mode you are on the last line.
set showmode

" Show matching words during a search.
set showmatch

" Use highlighting when doing a search.
set hlsearch

" Set the commands to save in history default number is 20.
set history=1000

Bash completion is a great feature which saves keystrokes by auto completing what you type. Vim has a similar feature called wildmenu.

Add the following lines to enable the wildmenu feature. You will see a list of files matching the file you are searching for. You can also enable auto completion to Vim.

" Enable auto completion menu after pressing TAB.
set wildmenu

" Make wildmenu behave like similar to Bash completion.
set wildmode=list:longest

" There are certain files that we would never want to edit with Vim.
" Wildmenu will ignore files with these extensions.
set wildignore=*.docx,*.jpg,*.png,*.gif,*.pdf,*.pyc,*.exe,*.flv,*.img,*.xlsx

Type :help <command> for more information on specific commands.

Example:

:help nocompatible

How to Fold Long Files in Vim

The .vimrc file can get long so organizing it into sections is a smart idea.
Vim will allow you to fold long files to hide sections of text.

Add the following lines to the bottom of your .vimrc to organize the file into sections.

" PLUGINS ---------------------------------------------------------------- {{{

" Plugin code goes here.

" }}}


" MAPPINGS --------------------------------------------------------------- {{{

" Mappings code goes here.

" }}}


" VIMSCRIPT -------------------------------------------------------------- {{{

" This will enable code folding.
" Use the marker method of folding.
augroup filetype_vim
    autocmd!
    autocmd FileType vim setlocal foldmethod=marker
augroup END

" More Vimscripts code goes here.

" }}}


" STATUS LINE ------------------------------------------------------------ {{{

" Status bar code goes here.

" }}}

Save the .vimrc file with :w and source the .vimrc file like this :source ~/.vimrc to make the changes take effect. Now, once you move your cursor on a fold you can press:

zo to open a single fold under the cursor.

zc to close the fold under the cursor.

zR to open all folds.

zM to close all folds.

Type :help folding for more information.

How to Add Plugins to Vim

You can add plugins to Vim to add extra functionality. Most people use a plugin manager to make plugin installation easy.

There are a variety of plugin managers we can use. I will show you how to install and use the vim-plug plugin manager.

To install the vim-plug plugin, run this command:

On Linux or Mac OS.

$ curl -fLo ~/.vim/autoload/plug.vim --create-dirs \
    https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim

On Windows with Powershell.

$ iwr -useb https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim |`
    ni $HOME/vimfiles/autoload/plug.vim -Force

Add the call plug#begin('~/.vim/plugged') and call plug#end() lines in the plugins section. The plugins we install will be added between the two function calls.

" PLUGINS ---------------------------------------------------------------- {{{

call plug#begin('~/.vim/plugged')




call plug#end()

" }}}

Now installing plugins is as easy as adding the Plug 'username/plugin-name' string you find on GitHub in between the function calls.

This is how I install NERDTree and Asynchronous Lint Engine (ALE).

Add these two lines in between the two call plug#... lines:

" PLUGINS ---------------------------------------------------------------- {{{

call plug#begin('~/.vim/plugged')


  Plug 'dense-analysis/ale'

  Plug 'preservim/nerdtree'


call plug#end()

" }}}

Save the .vimrc file with the command :w and source the .vimrc file with this command :source ~/.vimrc to make the changes take effect.

Now type :PlugInstall to download and install the two plugins.

How to Map Keyboard Shortcuts in Vim

In the mapping section we will add shortcuts to making typing longer commands easier. This will save you key strokes and lots of time, especially for long commands.

Key mapping syntax is like this:

map_mode <what_you_type> <what_is_executed>

Popular Mapping Modes in Vim

Here are a few popular mapping modes and probably the most useful and important.

• nnoremap – Allows you to map keys in normal mode.
• inoremap – Allows you to map keys in insert mode.
• vnoremap – Allows you to map keys in visual mode.

A common mapping example is to map 'jj' to the escape key. You will be pressing the escape key a lot. The escape key is in the far corner of the keyboard.
The letter 'j' is in the middle of the keyboard so it is easier to press 'jj' instead of reaching for the escape key.

This is how you would map the escape key to jj.

inoremap jj <esc>

How to Use Mapleader in Vim

Mapleader will allow you set a key unused by Vim as the <leader> key.
The leader key, in conjunction with another key, will allow you to create new shortcuts.

The backslash key is the default leader key but some people change it to a comma ",".

let mapleader = "\"

With the leader key mapped to backslash, I can use it like this:

Turn off search highlighting by pressing \\.
nnoremap <leader>\ :nohlsearch<CR>

Here are some common mappings that people use. See the comments above each line for the explanation.

Add this code in the mappings section:

" MAPPINGS --------------------------------------------------------------- {{{

" Set the backslash as the leader key.
let mapleader = "\"

" Press \\ to jump back to the last cursor position.
nnoremap <leader>\ ``

" Press \p to print the current file to the default printer from a Linux operating system.
" View available printers:   lpstat -v
" Set default printer:       lpoptions -d <printer_name>
" <silent> means do not display output.
nnoremap <silent> <leader>p :%w !lp<CR>

" Type jj to exit insert mode quickly.
inoremap jj <Esc>

" Press the space bar to type the : character in command mode.
nnoremap <space> :

" Pressing the letter o will open a new line below the current one.
" Exit insert mode after creating a new line above or below the current line.
nnoremap o o<esc>
nnoremap O O<esc>

" Center the cursor vertically when moving to the next word during a search.
nnoremap n nzz
nnoremap N Nzz

" Yank from cursor to the end of line.
nnoremap Y y$

" Map the F5 key to run a Python script inside Vim.
" I map F5 to a chain of commands here.
" :w saves the file.
" <CR> (carriage return) is like pressing the enter key.
" !clear runs the external clear screen command.
" !python3 % executes the current file with Python.
nnoremap <f5> :w <CR>:!clear <CR>:!python3 % <CR>

" You can split the window in Vim by typing :split or :vsplit.
" Navigate the split view easier by pressing CTRL+j, CTRL+k, CTRL+h, or CTRL+l.
nnoremap <c-j> <c-w>j
nnoremap <c-k> <c-w>k
nnoremap <c-h> <c-w>h
nnoremap <c-l> <c-w>l

" Resize split windows using arrow keys by pressing:
" CTRL+UP, CTRL+DOWN, CTRL+LEFT, or CTRL+RIGHT.
noremap <c-up> <c-w>+
noremap <c-down> <c-w>-
noremap <c-left> <c-w>>
noremap <c-right> <c-w><

" NERDTree specific mappings.
" Map the F3 key to toggle NERDTree open and close.
nnoremap <F3> :NERDTreeToggle<cr>

" Have nerdtree ignore certain files and directories.
let NERDTreeIgnore=['\.git$', '\.jpg$', '\.mp4$', '\.ogg$', '\.iso$', '\.pdf$', '\.pyc$', '\.odt$', '\.png$', '\.gif$', '\.db$']

" }}}

Type help: map-modes for more information.

How to Add Some Vimscripting

Vimscript is a scripting language that lets you create scripts using variables, if else statements, and functions. Auto commands are waiting for events to occur in order to trigger a command.

" VIMSCRIPT -------------------------------------------------------------- {{{

" Enable the marker method of folding.
augroup filetype_vim
    autocmd!
    autocmd FileType vim setlocal foldmethod=marker
augroup END

" If the current file type is HTML, set indentation to 2 spaces.
autocmd Filetype html setlocal tabstop=2 shiftwidth=2 expandtab

" If Vim version is equal to or greater than 7.3 enable undofile.
" This allows you to undo changes to a file even after saving it.
if version >= 703
    set undodir=~/.vim/backup
    set undofile
    set undoreload=10000
endif

" You can split a window into sections by typing `:split` or `:vsplit`.
" Display cursorline and cursorcolumn ONLY in active window.
augroup cursor_off
    autocmd!
    autocmd WinLeave * set nocursorline nocursorcolumn
    autocmd WinEnter * set cursorline cursorcolumn
augroup END

" If GUI version of Vim is running set these options.
if has('gui_running')

    " Set the background tone.
    set background=dark

    " Set the color scheme.
    colorscheme molokai

    " Set a custom font you have installed on your computer.
    " Syntax: set guifont=<font_name>\ <font_weight>\ <size>
    set guifont=Monospace\ Regular\ 12

    " Display more of the file by default.
    " Hide the toolbar.
    set guioptions-=T

    " Hide the the left-side scroll bar.
    set guioptions-=L

    " Hide the the right-side scroll bar.
    set guioptions-=r

    " Hide the the menu bar.
    set guioptions-=m

    " Hide the the bottom scroll bar.
    set guioptions-=b

    " Map the F4 key to toggle the menu, toolbar, and scroll bar.
    " <Bar> is the pipe character.
    " <CR> is the enter key.
    nnoremap <F4> :if &guioptions=~#'mTr'<Bar>
        \set guioptions-=mTr<Bar>
        \else<Bar>
        \set guioptions+=mTr<Bar>
        \endif<CR>

endif

" }}}

Read Learn Vimscript the Hard Way for more information on Vimscript.

Type :help autocmd for more information on auto commands.

How to Add Color Schemes to Vim

You can easily add color schemes to Vim to change the default colors. Do a search for Vim color schemes and you will find many, many choices.

Installing a color scheme is a simple as adding a <colorscheme>.vim file to the ~/.vim/colors/ directory.

I will add the popular color scheme molokai:

$ cd ~/.vim/colors

$ curl -o molokai.vim https://raw.githubusercontent.com/tomasr/molokai/master/colors/molokai.vim
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100  7558  100  7558    0     0   150k      0 --:--:-- --:--:-- --:--:--  150k

To set the color scheme, type this command:

:colorscheme molokai

Example color schemes:

color schemes: molokai, base16-tomorrow, blue, one

How to Configure the Status Bar in Vim

You can configure your Vim status bar with useful information. For example, configure the file type, total number of lines in the file, path to the file, column number, row number, percentage through file, and much more.

Add this code in the status line section:

" STATUS LINE ------------------------------------------------------------ {{{

" Clear status line when vimrc is reloaded.
set statusline=

" Status line left side.
set statusline+=\ %F\ %M\ %Y\ %R

" Use a divider to separate the left side from the right side.
set statusline+=%=

" Status line right side.
set statusline+=\ ascii:\ %b\ hex:\ 0x%B\ row:\ %l\ col:\ %c\ percent:\ %p%%

" Show the status on the second to last line.
set laststatus=2

" }}}

%F – Display the full path of the current file.

%M – Modified flag shows if file is unsaved.

%Y – Type of file in the buffer.

%R – Displays the read-only flag.

%b – Shows the ASCII/Unicode character under cursor.

0x%B – Shows the hexadecimal character under cursor.

%l – Display the row number.

%c – Display the column number.

%p%% – Show the cursor percentage from the top of the file.

Type help: statusline for more information.

This is the complete .vimrc file.

"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""               
"               
"               ██╗   ██╗██╗███╗   ███╗██████╗  ██████╗
"               ██║   ██║██║████╗ ████║██╔══██╗██╔════╝
"               ██║   ██║██║██╔████╔██║██████╔╝██║     
"               ╚██╗ ██╔╝██║██║╚██╔╝██║██╔══██╗██║     
"                ╚████╔╝ ██║██║ ╚═╝ ██║██║  ██║╚██████╗
"                 ╚═══╝  ╚═╝╚═╝     ╚═╝╚═╝  ╚═╝ ╚═════╝
"               
"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""               

" Disable compatibility with vi which can cause unexpected issues.
set nocompatible

" Enable type file detection. Vim will be able to try to detect the type of file is use.
filetype on

" Enable plugins and load plugin for the detected file type.
filetype plugin on

" Load an indent file for the detected file type.
filetype indent on

" Turn syntax highlighting on.
syntax on

" Add numbers to the file.
set number

" Highlight cursor line underneath the cursor horizontally.
set cursorline

" Highlight cursor line underneath the cursor vertically.
set cursorcolumn

" Set shift width to 4 spaces.
set shiftwidth=4

" Set tab width to 4 columns.
set tabstop=4

" Use space characters instead of tabs.
set expandtab

" Do not save backup files.
set nobackup

" Do not let cursor scroll below or above N number of lines when scrolling.
set scrolloff=10

" Do not wrap lines. Allow long lines to extend as far as the line goes.
set nowrap

" While searching though a file incrementally highlight matching characters as you type.
set incsearch

" Ignore capital letters during search.
set ignorecase

" Override the ignorecase option if searching for capital letters.
" This will allow you to search specifically for capital letters.
set smartcase

" Show partial command you type in the last line of the screen.
set showcmd

" Show the mode you are on the last line.
set showmode

" Show matching words during a search.
set showmatch

" Use highlighting when doing a search.
set hlsearch

" Set the commands to save in history default number is 20.
set history=1000

" Enable auto completion menu after pressing TAB.
set wildmenu

" Make wildmenu behave like similar to Bash completion.
set wildmode=list:longest

" There are certain files that we would never want to edit with Vim.
" Wildmenu will ignore files with these extensions.
set wildignore=*.docx,*.jpg,*.png,*.gif,*.pdf,*.pyc,*.exe,*.flv,*.img,*.xlsx

" PLUGINS ---------------------------------------------------------------- {{{

call plug#begin('~/.vim/plugged')

  Plug 'dense-analysis/ale'

  Plug 'preservim/nerdtree'

call plug#end()

" }}}

" MAPPINGS --------------------------------------------------------------- {{{

" Set the backslash as the leader key.
let mapleader = "\"

" Press \\ to jump back to the last cursor position.
nnoremap <leader>\ ``

" Press \p to print the current file to the default printer from a Linux operating system.
" View available printers:   lpstat -v
" Set default printer:       lpoptions -d <printer_name>
" <silent> means do not display output.
nnoremap <silent> <leader>p :%w !lp<CR>

" Type jj to exit insert mode quickly.
inoremap jj <Esc>

" Press the space bar to type the : character in command mode.
nnoremap <space> :

" Pressing the letter o will open a new line below the current one.
" Exit insert mode after creating a new line above or below the current line.
nnoremap o o<esc>
nnoremap O O<esc>

" Center the cursor vertically when moving to the next word during a search.
nnoremap n nzz
nnoremap N Nzz

" Yank from cursor to the end of line.
nnoremap Y y$

" Map the F5 key to run a Python script inside Vim.
" We map F5 to a chain of commands here.
" :w saves the file.
" <CR> (carriage return) is like pressing the enter key.
" !clear runs the external clear screen command.
" !python3 % executes the current file with Python.
nnoremap <f5> :w <CR>:!clear <CR>:!python3 % <CR>

" You can split the window in Vim by typing :split or :vsplit.
" Navigate the split view easier by pressing CTRL+j, CTRL+k, CTRL+h, or CTRL+l.
nnoremap <c-j> <c-w>j
nnoremap <c-k> <c-w>k
nnoremap <c-h> <c-w>h
nnoremap <c-l> <c-w>l

" Resize split windows using arrow keys by pressing:
" CTRL+UP, CTRL+DOWN, CTRL+LEFT, or CTRL+RIGHT.
noremap <c-up> <c-w>+
noremap <c-down> <c-w>-
noremap <c-left> <c-w>>
noremap <c-right> <c-w><

" NERDTree specific mappings.
" Map the F3 key to toggle NERDTree open and close.
nnoremap <F3> :NERDTreeToggle<cr>

" Have nerdtree ignore certain files and directories.
let NERDTreeIgnore=['\.git$', '\.jpg$', '\.mp4$', '\.ogg$', '\.iso$', '\.pdf$', '\.pyc$', '\.odt$', '\.png$', '\.gif$', '\.db$']

" }}}

" VIMSCRIPT -------------------------------------------------------------- {{{

" Enable the marker method of folding.
augroup filetype_vim
    autocmd!
    autocmd FileType vim setlocal foldmethod=marker
augroup END

" If the current file type is HTML, set indentation to 2 spaces.
autocmd Filetype html setlocal tabstop=2 shiftwidth=2 expandtab

" If Vim version is equal to or greater than 7.3 enable undofile.
" This allows you to undo changes to a file even after saving it.
if version >= 703
    set undodir=~/.vim/backup
    set undofile
    set undoreload=10000
endif

" You can split a window into sections by typing `:split` or `:vsplit`.
" Display cursorline and cursorcolumn ONLY in active window.
augroup cursor_off
    autocmd!
    autocmd WinLeave * set nocursorline nocursorcolumn
    autocmd WinEnter * set cursorline cursorcolumn
augroup END

" If GUI version of Vim is running set these options.
if has('gui_running')

    " Set the background tone.
    set background=dark

    " Set the color scheme.
    colorscheme molokai

    " Set a custom font you have installed on your computer.
    " Syntax: <font_name>\ <weight>\ <size>
    set guifont=Monospace\ Regular\ 12

    " Display more of the file by default.
    " Hide the toolbar.
    set guioptions-=T

    " Hide the the left-side scroll bar.
    set guioptions-=L

    " Hide the the left-side scroll bar.
    set guioptions-=r

    " Hide the the menu bar.
    set guioptions-=m

    " Hide the the bottom scroll bar.
    set guioptions-=b

    " Map the F4 key to toggle the menu, toolbar, and scroll bar.
    " <Bar> is the pipe character.
    " <CR> is the enter key.
    nnoremap <F4> :if &guioptions=~#'mTr'<Bar>
        \set guioptions-=mTr<Bar>
        \else<Bar>
        \set guioptions+=mTr<Bar>
        \endif<CR>

endif

" }}}

" STATUS LINE ------------------------------------------------------------ {{{

" Clear status line when vimrc is reloaded.
set statusline=

" Status line left side.
set statusline+=\ %F\ %M\ %Y\ %R

" Use a divider to separate the left side from the right side.
set statusline+=%=

" Status line right side.
"set statusline+=\ ascii:\ %b\ hex:\ 0x%B\ row:\ %l\ col:\ %c\ percent:\ %p%%

" Show the status on the second to last line.
set laststatus=2

" }}}

Conclusion

In this article, I have only scratched the surface of how you can customize Vim.
There are thousands of ways to configure and customize a .vimrc to your liking.
You can even write your own plugins and color schemes and share them with the world.

I hope that you have learned a new trick or two by reading this article. So if you use Vim, don't leave home without a .vimrc file!

By the way, I used Vim to write this article.

Follow me on Github | DEV.to

While a multitude of methods exist to search for and replace words in a single file, what do you do when you’ve got a string to update across multiple unrelated files, all with different names? You harness the power of command line tools, of course!

First, you’ll need to find all the files you want to change. Stringing together what are effectively search queries for find is really only limited by your imagination.

Here’s a simple example that finds Python files:

find . -name '*.py'

The -name test searches for a pattern, such as all files ending in .py. But find can do a lot more with other test conditions, including -regex tests. Run find --help to see the multitude of options.

Further tune your search by using grep to get only the files that contain the string you want to change, such as by adding:

grep -le '\<a whale\>'

The -l option gives you just the file names for all files containing a pattern (denoted with -e) that match “a whale”.

You can also use Vim’s impressive :bufdo which lets you run the same command across multiple buffers. It interactively works with all of these files without the tedium of opening, saving, and closing each file, one at a time.

Let’s plug your powerful find+grep results into Vim with:

vim `find . -name '*.py' \
-exec grep -le '\<a whale\>' {} \;`

Using backtick-expansion to pass our search to Vim opens up multiple buffers ready to go. (Do :h backtick-expansion in Vim for more.)

Now you can apply the Vim command :bufdo to all of these files and perform actions such as interactive search-and-replace:

:bufdo %s/a whale/a bowl of petunias/gce

The g for “global” will change occurrences of the pattern on all lines. The e will omit errors if the pattern is not found. The c option makes this interactive. If you’re feeling confident, you can omit it to make the changes without reviewing each one.

When you’ve finished going through all the buffers, save all the work you’ve completed with:

:bufdo wq!

Then bask in the glory of your saved time and effort.

Whether you're forced to use VIM at your workplace or you're a mad VIM fan like I am who obsesses about productivity, the project-wide keyword search is a basic requirement every developer needs in their editor's arsenal. And we expect it to be blazing fast. ⚡️

I've been using VIM for about 3 years now. And coming from a Sublime background, the need for project-wide search was essential.

ripgrep and ack.vim were things I adopted early on after my unfulfilling experiences with grep and the_silver_searcher(ag). I haven't looked back since then.

This article is the result of experimenting with different search tools and incremental improvements I made over a period of time until it felt just right.

Why ack.vim & ripgrep?

1. Fast: I've worked on Symfony and JavaScript projects with thousands of files and it is just blazing fast. Here's a quick comparison with other search tools.
   My benchmark for speed is, "it should never feel slow". I noticed a tremendous improvement after I moved from grep, the_silver_searcher and ack.

2. Quick navigation: ack.vim takes care of populating the Quickfix list, which lets you conveniently move through all those search results across different files.

3. Sensible defaults: ripgrep by default considers gitignore and automatically skips hidden files/directories and binary files.

Overview

ack.vim is a VIM plugin that acts as a wrapper to search keywords and populate the Quickfix list for navigating the results.

ripgrep (rg) is a command-line tool that ack.vim will internally use to perform the actual project-wide search.

Steps

Step 1: Install ripgrep

If you prefer Homebrew like I do, run the following to install rg:

brew tap burntsushi/ripgrep https://github.com/BurntSushi/ripgrep.git
brew install burntsushi/ripgrep/ripgrep-bin

Here's an automated script which I use as part of my dotfiles.

If you prefer any other mode of installation, refer to ripgrep's official installation section.

Step 2: Install ack.vim

To install ack.vim using the vim-plug package manager, add the following in your vimrc:

Plug 'mileszs/ack.vim'

or refer to the ack.vim's installation section.

Step 3: Configure ack.vim to use rg

Add the following configuration in your vimrc:

" ack.vim --- {{{

" Use ripgrep for searching ⚡️
" Options include:
" --vimgrep -> Needed to parse the rg response properly for ack.vim
" --type-not sql -> Avoid huge sql file dumps as it slows down the search
" --smart-case -> Search case insensitive if all lowercase pattern, Search case sensitively otherwise
let g:ackprg = 'rg --vimgrep --type-not sql --smart-case'

" Auto close the Quickfix list after pressing '<enter>' on a list item
let g:ack_autoclose = 1

" Any empty ack search will search for the work the cursor is on
let g:ack_use_cword_for_empty_search = 1

" Don't jump to first match
cnoreabbrev Ack Ack!

" Maps <leader>/ so we're ready to type the search keyword
nnoremap <Leader>/ :Ack!<Space>
" }}}

" Navigate quickfix list with ease
nnoremap <silent> [q :cprevious<CR>
nnoremap <silent> ]q :cnext<CR>

Note: let g:ackprg defines the command which ack.vim will internally run.
Also note that we're using rg here with some options. Look at the man rg to modify the options that may meet your requirements.

To explore options for ack.vim, look into the following documentation.

Usage

Now that we're up and ready, here are the most common use-cases:

Look for a word under the cursor

Press / followed by enter.
Since we've set let g:ack_use_cword_for_empty_search = 1, Ack falls back to the current word under the cursor for the search, so no need to type that word.

Word search

Press / followed by the word (without any quotes) & enter.
Since we're using smart case with ripgrep, that'll do a case insensitive search if the word is all lowercase, and a case sensitive search otherwise.

word search with ack.vim

Regex search

Press / followed by a regex pattern in quotes & enter.

regex search with ack.vim

Navigation through the results

Ack.vim populates the results in the Quickfix list, which opens up as a separate bottom window. There are multiple ways to navigate the results list:

• You can navigate the Quickfix list using j/k and press enter to close the Quickfix list. VIM will take you to the exact location of the found word.

• You can also use the hotkeys ]q or [q. VIM will move the cursor to the next/previous result and will open the file in a new buffer if required.
  To close the Quickfix list once you're done, you can either go to the bottom Quickfix window and close it or just run :cclose

• To open the Quickfix list back up, run :copen

Closing Note

And there you have it, a seamless search and navigation for your next project-wide keyword search!

If you're stuck anywhere, look for the respective ack.vim and ripgrep docs/issues in their respective repositories, or send me a message. Share the configuration you're proud of, so it can help others improve theirs.

Here are my dotfiles.

But if you are using Windows as your operating system, you will need to install Vim separately.

Fortunately, Microsoft makes it very easy to install Vim and get it running on your PC.

How to Download Vim

You can download the latest version of the Vim Text Editor straight from Vim themselves.

They have built a special self-executing installer that walks you through the process of installing Vim in the right location on your hard drive.

How to Install Vim

Note that for Windows you will technically download something called gVim, which is a version of Vim that includes a basic graphic user interface (GUI). You can install it by downloading this executable installer.

A screenshot of what you'll se when you attempt to open the file. Because this is an .exe file, Windows will ask your permission first.

Once you've downloaded the file, you just need to run it, and you'll see a nice installation wizard that looks like this:

A screenshot of the wizard you'll see when you first run the Vim installer

They have a recommended "typical" installation. but if you have a reasonably large hard drive, there's no harm in going ahead with installing everything by choosing the "full" option:

A screenshot of the Vim installer where you can choose what parts of Vim you want to install.

How to Run Vim in PowerShell

Then, once you've installed Vim, you should be able to launch it from your Windows command prompt.

Note that as of 2020, PowerShell has all of the same functionality as CMD, plus a whole lot more. I recommend using PowerShell for everything.

You can open PowerShell from the Windows menu bar by typing "powershell" in the search field on the start bar.

Windows will open PowerShell, and you'll get a command prompt that looks something like this:

A screenshot of the Windows PowerShell prompt.

Once you're in PowerShell, here's how to run Vim itself. All you have to do is type "vim" and press enter. This will open up Vim. Once Vim is open, this is what you should see:

A screenshot of Vim when you open it for the first time.

Congratulations – you now have Vim installed.

How to run Vim inside VS Code

If you are already using VS Code, and want a lot of the speed of Vim without losing the functionality of VS Code, I have good news. It is possible to run a Vim-like experience right within VS Code.

Here is a Vim plugin for VS Code that will help you do this. At the time of me writing this, this plugin has been installed nearly 2 million times.

How to Learn How to Use Vim Properly

Vim is a powerful code editor, and it will take you a lot of practice to get comfortable with it.

Here are a few Vim tutorials that will really help you quickly grasp the basics and get your fingers flying in no time.

For starters, one way Vim is different from other code editors is that Vim has "modes". Here are all of Vim's modes explained, with examples.

Vim can be intimidating. There is so much to learn. But this guide will show you how not to be afraid of Vim anymore.

If you're already using VS Code and want to switch completely to Vim, this article will explain how you can do so.

And here are 7 Vim Tips That Changed #100DaysOfCode founder Alex Kallaway's life. In this article, he not only explain these, but shows demos of these tips in action.

Vim: Learn it, live it, love it.

In the 30 years since Bram Moolenaar first created Vim, its influence has spread far and wide. And even today, the Vim project is actively maintained and constantly improving.

I've met so many developers over the years who swear by Vim.

I hope this guide has helped you get running Vim on your Windows PC. And I hope these other tutorials I've shared with you here will help you go from zero-to-sixty within the coming months.

The key is to keep practicing and not get discouraged by how many Vim shortcuts there are to remember. Eventually, all of these will become muscle memory, and you'll be flying from one file to another, banging out code like a terminator.

There is no feeling quite as cool as being able to drop into a codebase and immediately start making changes without ever even reaching for a mouse or trackpad. That is the power that Vim promises, and delivers in spades.

Hi, fellow coders! You may have heard of the Vim code editor before, or even used it a bit.

There are plenty of resources out there that cover the basics of Vim and I don't want to just do another rewrite of those here. Instead, I want to share some quick tips that I've learned from others while using Vim full time at work.

These are tiny things that you can learn quickly that will make a big difference in your day-to-day work in Vim. They'd definitely made my life easier.

Remember: Vim comes pre-installed on Mac and Linux. You just need to open up your terminal and type "vim" in the command prompt, and you'll open Vim. If you have a Windows computer, follow these instructions to install Vim on your PC.

Before we begin

If you're interested in Vim but haven't started yet, these are the resources I'd like to recommend:

• OpenVim - Interactive Vim Tutorial
• vimtutor - this is an interactive command line tutorial that's available and installed on Macs and some Linux distros. Just type vimtutor in your terminal
• VimAdventures - First couple of levels are free, and if you like the format, and the full license is $25

If you like Vim but it's too much to run it on its own, install a Vim extension for your favourite editor, like VS Code or Sublime or any other. That way you get to use the quick actions and shortcuts of Vim and a friendlier interface you're more used to.

One important realization I had about learning and working with Vim: you don't need to master everything (which is practically impossible anyway) to start using it.

Once you figure out the basics, every time you have a question or a block throughout your workday, write it down, and then go through that list and search the Internet for how to do that in Vim.

This way, you will incrementally fill any gaps you might have and will become better with each new little thing you add to your repertoire (these micro-improvements will be similar to the tips in this article below).

Now let's proceed to the fun stuff – the tips and tricks. You don't have to have any Vim plugins installed to take advantage of these.

1. How to start writing on a line at correct indentation

Before I learned this, I used to jump on a new line and go to insert mode, TAB to the right indentation and start typing code. With this little trick, you won't have to do do all the extra tabbing, it will just place you in insert mode at the right indentation.

RECIPE: S (SHIFT+s)

DEMO:

2. Resize windows automatically

Very often we do something with windows inside Vim that causes them to be resized incorrectly, sometimes one being way too wide and the other way too narrow.

The easiest way to see that effect is to open 3 windows in one Vim tab and resize the terminal window in which you opened Vim.

You want to resize the windows to all be the same size, with available space evenly distributed. Good news is, you don't have to do it manually.

RECIPE: CTRL+w =

The combination of CTRL+w, followed by pressing the equals sign key will equalize the windows.

DEMO:

3. Jump to the matching bracket/brace

With your cursor on a square [ or round ( bracket or a curly brace {, press % (SHIFT+5) to jump to its matching symbol. Press it again to jump back (toggle between them).

if (condition) {
  // code
}
// If your cursor was on {, and you pressed %, you'd jump to }

RECIPE: % with your cursor on the character you want to find a match to.

DEMO:

4. Indent/Unindent a line or multiple lines

>> ⁠– indents a line
<< ⁠– unindents a line

When you have multiple lines selected (in VISUAL LINE mode), you only need to press > or < once to indent or unindent the lines (as shown in demo below)

It doesn't matter where your cursor is positioned in the line when indenting - it will still work. After indent is done, cursor is auto-positioned on first non-empty character in the line.

RECIPE: One line: >>, <<. Multiple lines: >, <.

DEMO:

5. Fix indentation in the whole file

Start in the top of a file (to get there, press gg anywhere in the file.). Then press =G, and Vim will fix the indentation in the whole file. If you don't start in the beginning of the file, it will fix indentation from current line to the bottom of file.

RECIPE: =G

Press the equals sign, followed by SHIFT+G

DEMO:

6. Basics of working with tabs

Often you want to be looking at multiple files or contexts at the same time. Vim tabs are very handy but underutilized feature for this. I don't know of any other editor that supports this (but I'm sure there is a way to do it elsewhere).

For example, I like to keep my code related files in my main tab, and in another tab: README with a TODO list and a place I can jot down further ideas.

To write the commands to work with tabs, you will need to be in command mode. To start writing the command, press : and type. The command will show up in the left bottom corner of the editor as you are typing. Press enter to execute.

RECIPE:
:tabnew creates a new tab
gt - go to next tab
gT - go to previous tab
:tabo - close all other tabs besides the active one

DEMO:

7. How to quickly go back to a previous file

Often, when you edit a file with code, you open another one in the same window. Then it's not so easy to come back to the one you just worked on. You could list buffers and navigate to the previous one but you need to remember its name for that and spend your precious time. Vim users don't like to spend too much time on actions. :) So you can use CTRL+o for this.

All it does is that it finds a previous position of your cursor - and if it happened to be in a different file (the one you just lost by opening a new one), it jumps us right back there.

Thank you for reading and I hope these tips serve you well!

? If you want to follow my adventures, here's my Twitter :)

? I write a weekly newsletter that covers topics like learning to code, changing habits, personal finance, book recommendations & key takeaways, minimalism, starting a business, psychology and more. For those of you who are interested: join 1K+ like-minded people passionate about self-improvement and learning.
Subscribe here

? These days I am working on my side project - an app called "Zerno". Sign up to get early access very soon!
ZERNO app

Normal Mode

By default, Vim starts in “normal” mode. Normal mode can be accessed from other modes by pressing Esc or <C-[>.

In Normal mode key presses don’t work as one would expect. That is, they don’t insert text into the document; instead, certain key presses can:

Move the cursor

• h move one character left
• j move one row down
• k move one row up
• l move one character right

As many vim commands, row movement can be prefixed by a number to move s everal lines at a time:

• 4j move 4 rows down
• 6k move 6 rows up

Basic word movements:

• w move to beginning of next word
• b move to previous beginning of word
• e move to end of word
• W move to beginning of next word after a whitespace
• B move to beginning of previous word before a whitespace
• E move to end of word before a whitespace

Beginning/End of line movement:

• 0 move to the beginning of the line
• $ move to the end of the line

Manipulate text

Enter other modes

Normal mode is where one should spend most of their time while using Vim. Remember, this is what makes Vim different.

In normal mode, there are multiple ways to move around an open file. In addition to using the cursor keys to move around, you can use h (left), j (down), k (up), and l (right) to move as well. This particularly helps touch typists who don’t like leaving the home row when making changes.

You can also make changes to single characters in normal mode. For example, to replace a single character, move your cursor over it and press r, and then the character you want to replace it with. Similarly, you can delete single characters by moving your cursor over it and pressing x.

To perform an undo, press u in normal mode. This undoes changes up to the last time you were in normal mode. If you want to redo (i.e., undo your undo) press Ctrl+r in normal mode.

Insert Mode

This is the second most used mode, and will be the most familiar behavior to most people. Once in insert mode, typing inserts characters just like a regular text editor. You can enter it by using an insert command from normal mode.

Insert commands include:

• i for ’insert’, this immediately switches vim to insert mode
• a for ’append’, this moves the cursor after the current character and enters insert mode
• o inserts a new line below the current line and enters insert mode on the new line

These commands have an uppercase variety too:

• I moves the cursor to the beginning of the line and enters insert mode
• A moves the cursor to the end of the line and enters insert mode
• O inserts a new line above the current one and enters insert mode on the new line

There are so many more ways of inserting text in Vim that can’t be listed here but these are the simplest. Also, beware of staying in insert mode for too long; Vim is not designed to be used in insert mode all the time.

To leave insert mode and return to normal mode, press Esc or <C-[>

Visual Mode

Visual mode is used to make selections of text, similar to how clicking and dragging with a mouse behaves. Selecting text allows commands to apply only to the selection, such as copying, deleting, replacing, and so on.

To make a text selection:

• Press v to enter visual mode, this will also mark a starting selection point
• Move the cursor to the desired end selection point; vim will provide a visual highlight of the text selection

Visual mode also has the following variants:

• V to enter visual line mode, this will make text selections by line
• <C-V> to enter visual block mode, this will make text selections by blocks; moving the cursor will make rectangle selections of the text

To leave visual mode and return to normal mode, press Esc or <C-[>.

The visual mode actually has multiple subtypes: visual, block-visual and linewise-visual

• visual: like described above. Enter by pressing v
• block-visual: select any rectangular region. Enter by pressing <ctrl>+v
• linewise-visual: always select full lines. Enter by pressing <shift>+v

Command Mode

Command mode has a wide variety of commands and can do things that normal mode can’t do as easily. To enter command mode type ’:’ from normal mode and then type your command which should appear at the bottom of the window. For example, to do a global find and replace type :%s/foo/bar/g to replace all ‘foo’ with ‘bar’

• : Enters command mode
• % Means across all lines
• s Means substitute
• /foo is regex to find things to replace
• /bar/ is regex to replace things with
• /g means global, otherwise it would only execute once per line

Vim has a number of other methods that you can read about in the help documentation, :h or :help.

Replace Mode

Replace mode allows you replace existing text by directly typing over it. Before entering this mode, get into normal mode and put your cursor on top of the first character that you want to replace. Then press ‘R’ (capital R) to enter replace mode. Now whatever you type will replace the existing text. The cursor automatically moves to the next character just like in insert mode. The only difference is that every character you type will replace the existing one.