Vim Cheat Sheet for DevOps and Linux Admins

Share on Social Media

Master Text Editing in Linux with this ultimate VIM cheat sheet tailored for DevOps and Linux Admins. Learn essential commands, shortcuts, plugins, and pro tips to boost your productivity in the terminal. #centlinux #linux #ubuntu

Introduction to Vim

What is Vim?

Vim, short for “Vi Improved,” is a highly configurable, powerful text editor that is an enhanced clone of the vi editor distributed with most UNIX systems. While it was created decades ago, its value hasn’t diminished—in fact, it’s only grown stronger in the realm of DevOps and Linux system administration. Vim operates primarily in a command-line environment, and it’s known for being lightweight, blazing fast, and incredibly robust once you master its shortcuts and commands.

Imagine having a tool that lets you move, edit, and manipulate files faster than any GUI-based editor. That’s Vim. It may look intimidating at first glance, but once you’re past the initial learning curve, it becomes a game-changer. Vim doesn’t just edit text—it becomes an extension of your hands on the keyboard.

What makes Vim particularly special is its modal nature. Unlike standard editors where you’re either typing or not, Vim separates concerns. There’s a mode for inserting text, one for navigating, another for selecting, and one for executing commands. This design makes your workflow more efficient once mastered.

Vim is installed by default on almost every Linux distribution, making it an essential tool in the toolkit of every Linux admin or DevOps engineer. No need to fumble around trying to install a new editor on a remote server—Vim is already there, ready for action.

Vim Cheat Sheet for DevOps and Linux Admins

Why Vim is Essential for DevOps and Linux Admins

For DevOps and Linux admins, Vim isn’t just another tool—it’s a survival kit. Here’s why Vim should be your go-to editor:

Remote Editing: Working over SSH? Vim’s your best friend. No GUI, no problem.
Scripting Integration: It plays well with shell scripts, cron jobs, Dockerfiles, Ansible playbooks—you name it.
Speed and Efficiency: Once you learn the key commands, you’ll navigate and edit files faster than with any GUI.
Reliability: No crashing, no freezing. Vim just works, even on machines with minimal resources.
Ubiquity: It’s available on practically every Unix-based system. You never have to worry about it being missing.

Think of Vim as a Swiss army knife for DevOps. Whether you’re editing a Kubernetes YAML file, tweaking a Bash script, or modifying a system configuration file deep inside /etc, Vim has your back.

Recommended Training: Complete Linux Training Course to Get Your Dream IT Job 2025 from Imran Afzal

Getting Started with Vim

Install Vim Text Editor

Install Vim text editor process is usually straightforward because it comes pre-installed on many Linux distributions. But if for some reason it’s missing, you can install it easily depending on your OS:

Ubuntu/Debian:

sudo apt update 
sudo apt install vim

CentOS/RHEL:

sudo yum install vim

Arch Linux:

sudo pacman -S vim

macOS (with Homebrew):

brew install vim

Once installed, you can verify it with:

vim --version

You’ll see a list of features, compilation options, and version info—another clue to just how robust Vim text editor is.

Launching Vim and Understanding the Interface

To launch Vim text editor, simply type vim followed by a filename:

vim filename.txt

If the file exists, it opens. If not, it creates a new one. At first, you’ll see something that might resemble a blank terminal window with a ~ on the side. Those tildes indicate unused lines—don’t be alarmed.

The real trick is knowing what you’re looking at:

Status Bar: At the bottom, it shows the current mode, file name, and other helpful info.
Line Numbers: Optional but can be toggled.
Mode: This is crucial. You’re likely in “Normal” mode right now. More on that next.

Now, don’t panic. You’re in Vim text editor. You might be tempted to hit Ctrl+C or just close your terminal window out of frustration. Instead, let’s make sense of what’s going on.

Vim Modes Explained (Normal, Insert, Visual, Command)

Understanding Vim means understanding modes. Here’s a breakdown of the four key modes:

Normal Mode (default): You can navigate and perform operations like copy, paste, delete, etc. You’re not typing text here.
- Press Esc anytime to return to this mode.
Insert Mode: Where you actually type text.
- Enter this mode with i (insert before cursor), I (insert at line start), a (append after cursor), or A (append at line end).
- Exit to Normal mode with Esc.
Visual Mode: Used for selecting blocks of text.
- Enter with v (character mode), V (line mode), or Ctrl+v (block mode).
- Useful for copying, cutting, or formatting sections.
Command-Line Mode: For executing commands like save, quit, search, or replace.
- Enter this by pressing : from Normal mode.
- Example:
  - :wq (write and quit),
  - :q! (quit without saving),
  - :set number (show line numbers).

Each mode is a world of its own. The power of Vim lies in smoothly moving between them like a keyboard ninja. Think of modes as gears in a car—each serves a purpose, and switching at the right time keeps things running smoothly.

Redragon M810 Pro Wireless Gaming Mouse, 10000 DPI Wired/Wireless Gamer Mouse w/Rapid Fire Key, 8 Macro Buttons, 45-Hour Reliable Power Capacity and RGB Backlit for PC/Mac/Laptop

(2596)

$27.99 (as of April 23, 2025 16:14 GMT +00:00 – )

Essential Navigation Commands

Moving Around in a File

Navigating through files in Vim is one of its superpowers. Here’s how to move like a pro:

Arrow Keys: Yes, you can use them, but they’re slow. Instead, use:
- h (left), j (down), k (up), l (right)
Words and Paragraphs:
- w: Move forward a word
- b: Move backward a word
- }: Next paragraph
- {: Previous paragraph
Line Navigation:
- 0: Start of line
- ^: First non-whitespace character
- $: End of line
Scrolling:
- Ctrl+d: Half page down
- Ctrl+u: Half page up
- Ctrl+f: Full page forward
- Ctrl+b: Full page backward
Line Numbers:
- :set number: Show line numbers
- :set relativenumber: Show relative line numbers
- :set nonumber: Hide line numbers
Jump to Line:
- :10 goes to line 10
- G: Go to end of file
- gg: Go to start of file

Mastering these commands will save you from wasting time reaching for the mouse or using arrow keys endlessly.

Navigating Between Files and Buffers

DevOps work often means handling multiple files at once. Vim makes it seamless:

Open a file:
- :e filename: Edit a new file
Switch buffers:
- :bn: Next buffer
- :bp: Previous buffer
- :bd: Delete buffer (close file)
List open buffers:
- :ls or :buffers

Use these buffer commands like browser tabs—quick, easy toggling between files makes multi-file editing feel natural.

Editing Text Efficiently

Inserting and Deleting Text

Editing is where Vim really begins to shine. Forget about dragging your mouse or fumbling through menus—Vim text editor lets you manipulate text with laser precision using just your keyboard.

To insert text, you’ll need to enter Insert mode. Here are the main ways to do that:

i: Insert before the cursor
I: Insert at the beginning of the line
a: Append after the cursor
A: Append at the end of the line
o: Open a new line below
O: Open a new line above

These give you full control over how you enter text into your file. You’ll use i and a frequently, but o and O are lifesavers when you need to inject lines on the fly.

To delete text:

x: Delete the character under the cursor
X: Delete the character before the cursor
dd: Delete an entire line
dw: Delete a word
d$: Delete from cursor to end of line
d0: Delete from cursor to beginning of line

You can even combine deletion with motions. For example, d3w deletes the next three words.

Want to delete everything inside a set of quotes or parentheses? Use:

di": Delete inside quotes
di(: Delete inside parentheses

Mastering these lets you surgically remove or insert text with just a few keystrokes—no backspacing necessary.

Copying, Pasting, and Cutting (Yank, Paste, Delete)

Forget Ctrl+C and Ctrl+V—Vim does it smarter with yank, put, and delete:

Copy (Yank):
- yy: Yank (copy) an entire line
- yw: Yank a word
- y$: Yank to end of line
- yG: Yank to end of file
Paste (Put):
- p: Paste after the cursor
- P: Paste before the cursor
Cut (Delete):
- dd: Delete a line (and copy it)
- d3w: Delete 3 words
- d}: Delete a paragraph

These commands make it lightning fast to move code blocks or configuration sections from one spot to another.

Vim also uses registers to store what you yank or delete. So you can yank one thing, do something else, then come back and paste it—all without losing your clipboard.

Undo, Redo, and Repeat

We all make mistakes—even in Vim. The good news? Fixing them is easy.

Undo: u
- Press u repeatedly to undo multiple changes.
Redo: Ctrl+r
- Redoes what you just undid.
Repeat Last Command: .
- This one is magic. It repeats the last command—perfect for mass changes.

Made a mistake five steps ago? No sweat—Vim’s undo tree lets you rewind time. And the ability to redo gives you a safety net.

Searching and Replacing

Searching Text Within a File

Searching in Vim is both powerful and straightforward. You can search forward or backward, case-sensitive or insensitive, and even use regular expressions.

To search:

/pattern: Search forward for “pattern”
?pattern: Search backward
n: Jump to next match
N: Jump to previous match

Search modifiers:

\c: Case-insensitive (/foo\c)
\C: Case-sensitive (/foo\C)

Want to highlight all matches? Use:

:set hlsearch

You can turn it off with:

:nohlsearch

This is ideal when scanning through large config files, logs, or codebases.

Using Find and Replace Commands

Vim’s find and replace is deadly accurate and fast:

Basic usage:

:%s/old/new/g

This replaces all occurrences of “old” with “new” in the entire file.

Breakdown:

%: Applies to all lines
s: Substitute
g: Replace all instances in a line (not just the first)

Replace only in a range:

:10,20s/old/new/g

Add confirmation before replacing:

:%s/old/new/gc

This is a lifesaver when you’re fixing config parameters or refactoring code across large files.

TP-Link Archer BE6500 Dual-Band Wi-Fi 7 Router (Archer BE400) | Dual 2.5 Gbps Ports USB 3.0 | Covers up to 2,400 Sq. ft and 90 Devices | Quad-core CPU| HomeShield, Private IoT for Network Security

(91)

$149.99 (as of April 23, 2025 16:07 GMT +00:00 – )

Working with Multiple Files

Opening and Managing Multiple Files

Managing multiple files is a daily routine in DevOps, and Vim makes it surprisingly simple.

To open multiple files:

vim file1.txt file2.txt

To switch between them:

:n: Go to next file
:prev: Go to previous file
:args: See the list of open files

You can also use the :e command:

:e /path/to/anotherfile

If you want to keep one file open while editing another, use buffers (more on that in the next section). Vim treats each file as a buffer behind the scenes, and once you get used to it, toggling between files becomes seamless.

Working with Tabs and Buffers

Let’s demystify buffers, windows, and tabs:

Buffers are files loaded into memory.
Windows are views into those buffers.
Tabs group windows together.

To open a file in a new tab:

:tabnew filename

Navigate tabs:

:tabn: Next tab
:tabp: Previous tab
gt: Go to next tab
gT: Go to previous tab

Working with buffers:

:ls or :buffers: List open buffers
:b1: Switch to buffer #1
:bd: Delete buffer (close file)

With tabs and buffers, you can juggle multiple files, logs, and scripts without leaving your Vim session.

Useful Configuration Settings

Editing `.vimrc` for Customization

The .vimrc file is where Vim transforms from a basic text editor into a tailored coding environment. It’s like your personal Vim playbook—set it once, and Vim behaves just how you like it every time.

The .vimrc file typically lives in your home directory:

~/.vimrc

Here are some must-have settings for DevOps and Linux admins:

syntax on             " Enable syntax highlighting
set number            " Show line numbers
set relativenumber    " Show relative line numbers
set autoindent        " Auto-indent new lines
set smartindent       " Smarter indenting
set tabstop=4         " Number of spaces per tab
set shiftwidth=4      " Indentation amount
set expandtab         " Convert tabs to spaces
set cursorline        " Highlight the current line
set background=dark   " Better color scheme for dark terminals
set clipboard=unnamedplus " Use system clipboard

Want to save your cursor position every time you exit a file? Add:

autocmd BufReadPost *
  \ if line("'\"") > 0 && line("'\"") <= line("$") |
  \   exe "normal! g'\"" |
  \ endif

Customizing your .vimrc boosts efficiency like nothing else. You’re no longer wrestling with the defaults—you’re driving a fully-tuned machine.

Enabling Syntax Highlighting and Line Numbers

Vim supports syntax highlighting for virtually every language or config format under the sun.

Enable it globally:

syntax on

You can even specify filetypes manually:

:set filetype=sh
:set filetype=yaml

To enable line numbers:

:set number

For relative numbers (great for jumping around with 10j or 5k):

:set relativenumber

Line numbers help with navigation, debugging, and when reading logs or editing huge config files.

Advanced Vim Features for Power Users

Macros and Registers

Macros in Vim are like recorded keyboard shortcuts. You can record a sequence of commands and replay them as needed—ideal for repetitive tasks like formatting lines or adding annotations.

To record a macro:

Press q followed by a register (e.g., q a to record into register a)
Perform your actions
Press q again to stop recording

To run the macro:

@a: Executes macro stored in register a
@@: Repeats the last executed macro

You can even do it multiple times:

10@a

Registers store text you’ve yanked, deleted, or recorded macros into. List them with:

:registers

Combining macros with registers allows for extremely powerful and repetitive editing capabilities—perfect for sysadmins processing logs or DevOps engineers updating repetitive YAML blocks.

Using Marks and Jumping Efficiently

Marks in Vim let you “bookmark” locations within your files so you can jump back instantly.

ma: Mark current location with letter a
'a: Jump to the line of mark a
`a: Jump to the exact cursor position of mark a

Use capital letters (e.g., mA) to mark positions across files. This is super helpful when debugging across multiple log files or editing several config files.

There are also special marks:

: Return to the previous position
': Return to previous jump location

In combination with search and macros, marks make navigation lightning-fast.

Vim Plugins for DevOps and Admin Tasks

Popular Plugins (NERDTree, Fugitive, etc.)

Vim plugins can supercharge your workflow. Here are a few must-haves:

NERDTree: File system explorer that shows directory structure in a side pane.
vim-fugitive: Git wrapper inside Vim. Stage, commit, and push from inside Vim.
vim-airline: Gorgeous status line showing buffer info, filetype, and git branch.
vim-commentary: Easy commenting/uncommenting of lines.
ctrlp.vim: Fuzzy file finder for opening files faster.

These plugins are game-changers. With them, Vim text editor starts to feel like a full IDE—but lighter and faster.

Managing Plugins with Vim-Plug

Vim-Plug is the go-to plugin manager for Vim users.

Install it by adding this to your .vimrc:

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

Plug 'preservim/nerdtree'
Plug 'tpope/vim-fugitive'
Plug 'vim-airline/vim-airline'
Plug 'tpope/vim-commentary'
Plug 'ctrlpvim/ctrlp.vim'

call plug#end()

Then run:

:source ~/.vimrc
:PlugInstall

Boom—you’ve got plugins. Managing and updating them is now a breeze:

:PlugUpdate
:PlugClean
:PlugStatus

For DevOps folks who bounce between shell scripts, Dockerfiles, and YAMLs, plugins like these can make daily work way more efficient.

Practical DevOps Use Cases in Vim

Editing Configuration Files

From Nginx and Apache to systemd, editing config files is an everyday task for sysadmins. Vim is purpose-built for this.

Open your config:

sudo vim /etc/nginx/nginx.conf

Use:

:set syntax=nginx
:%s/server_name/yourdomain.com/gc to quickly change parameters
:set paste before pasting large blocks to prevent auto-indent chaos

Use folding (zc, zo) to hide or reveal config sections.

And remember:

sudo visudo

…opens the sudoers file in Vim with syntax checking. A life-saver.

Writing and Debugging Shell Scripts

Writing bash scripts in Vim is smooth when combined with the right .vimrc settings and plugins.

Enable auto-indenting:

filetype plugin indent on

Syntax check before running:

bash -n script.sh

Inside Vim, you can:

Use :!bash % to run the script
Yank/paste log snippets or error messages
Use split windows to debug (:vsp logfile.log)

A well-configured Vim makes writing and debugging shell scripts feel intuitive and powerful.

Common Shortcuts Every Linux Admin Should Know

Time-Saving Commands and Combinations

Knowing the right shortcuts in Vim is like having cheat codes in a video game. These combos boost your productivity and make everyday tasks faster.

Here are some universal shortcuts every DevOps and Linux admin should have burned into muscle memory:

Navigation
- gg – Go to the beginning of the file
- G – Go to the end of the file
- :n – Go to line number n
- zz – Center the current line
Editing
- ci" – Change text inside quotes
- ci( – Change text inside parentheses
- di[ – Delete inside brackets
- cc – Change (replace) an entire line
Yanking and Pasting
- yy – Yank (copy) a line
- p – Paste after the cursor
- P – Paste before the cursor
Undo/Redo
- u – Undo
- Ctrl + r – Redo
Window Management
- :vsp file – Vertical split with file
- :sp file – Horizontal split
- Ctrl + w, then arrow key – Move between splits
Search & Replace
- /search_term – Search
- :%s/old/new/g – Replace globally
- :%s/old/new/gc – Replace with confirmation
Macros
- qa – Start recording in register ‘a’
- @a – Execute macro ‘a’

These shortcuts alone can cut your file editing time in half. Combined with practice, they make you a true Vim wizard.

Ansible Automation Platform By Examples: Learn Ansible Automation Platform with step-by-step guide for the most common user scenarios

(2)

$9.99 (as of April 23, 2025 16:07 GMT +00:00 – )

Troubleshooting Vim Issues

Dealing with Common Errors and Mistakes

Let’s be real—Vim isn’t always sunshine and rainbows. When things go sideways, here’s how to get back on track.

Problem: Stuck in a mode

Solution: Press Esc multiple times. If in doubt, Esc always brings you back to Normal mode.

Problem: Vim doesn’t save the file

Solution: Use :w! to force save or ensure the file isn’t read-only. If needed: sudo vim filename

Problem: Syntax highlighting not working

Solution: Enable it manually:

:syntax on 
:filetype plugin indent on

Problem: Tabs are too wide or inconsistent

Fix with these .vimrc lines:

set tabstop=4 
set shiftwidth=4 
set expandtab

Problem: Accidentally opened Vim and don’t know how to quit

Don’t panic. Use one of these:
- :q – Quit
- :q! – Force quit
- :wq – Save and quit

General Troubleshooting Tips:

Use :messages to view errors.
Always check your .vimrc for typos.
Start Vim without configs using vim -u NONE to test raw behavior.

With time, Vim becomes second nature—and you’ll troubleshoot it like a champ.

Mastering Vim Text Editor Over Time

Practice Strategies for Daily Use

Mastery doesn’t come overnight, but with consistent use, Vim transforms from overwhelming to indispensable.

Here’s how to build your skills daily:

Use Vim text editor for everything—even small tasks.
Practice modes: Get comfortable switching between Normal, Insert, and Visual modes.
Set a goal per day:
- Day 1: Learn navigation commands
- Day 2: Practice yanking and pasting
- Day 3: Master search and replace
Use .vimrc tweaks to make Vim comfortable.
Force yourself not to touch the mouse. Keep fingers on the keyboard.

Just like learning a musical instrument, small daily reps lead to huge long-term gains.

Resources to Learn More Vim

Want to level up further? Check out these resources:

Vim Adventures – Fun and interactive game to learn Vim
:help command in Vim – The in-editor documentation is pure gold
Vimcasts.org – Screencasts and tutorials
Learn Vim the Hard Way
Reddit’s r/vim – Tips, tricks, and community help

The Vim community is massive and full of helpful people—don’t hesitate to explore it.

VIM Cheat Sheet

We’ve also included a one-page VIM Cheat Sheet in this article to give you quick access to all essential shortcuts. Perfect for printing or bookmarking for on-the-go reference!

Frequently Asked Questions (FAQs)

Q1: How can I remember all the Vim commands?
Start by mastering the basics and use cheat sheets. Over time, with repetition and usage, your muscle memory will take over. Tools like Vim Adventures also make learning fun.

Q2: Is Vim better than Nano for sysadmins?
Absolutely. While Nano is simpler, Vim is more powerful and efficient once learned. For tasks like config editing, scripting, and bulk changes, Vim is unbeatable.

Q3: Can I use Vim on Windows for DevOps tasks?
Yes! You can install Vim via Git Bash, Windows Subsystem for Linux (WSL), or even standalone packages. It works great on Windows when configured properly.

Q4: What’s the best way to learn Vim fast?
Force yourself to use it daily. Set learning goals, install a few helpful plugins, and gradually introduce new commands into your routine.

Q5: How do I recover files in Vim after a crash?
Use the swap recovery feature. Open the file, and Vim will prompt you to recover. You can also check ~/.vim/tmp or similar directories for backups.

Conclusion

Vim isn’t just a text editor. For DevOps and Linux admins, it’s a full-blown productivity engine that helps you work faster, think clearer, and handle everything from configs to code. It may be intimidating at first, but once you break through that learning curve, you’ll never want to go back.

In a world of GUIs and bloatware, Vim stands out by staying lean, clean, and wickedly fast. And the more time you invest, the more power it reveals. So if you’re serious about leveling up your Linux and DevOps skills, Vim is absolutely worth mastering.

Whether you’re editing crontabs, updating Dockerfiles, fine-tuning Nginx, or debugging Bash scripts, Vim will always have your back.

Searching for a skilled Linux admin? From server management to security, I ensure seamless operations for your Linux systems. Find out more on my Fiverr profile!

Struggling with AWS or Linux server issues? I specialize in configuration, troubleshooting, and security to keep your systems performing at their best. Check out my Fiverr profile for details.