How to Undo and Redo Changes in Vim and Vi

When working inside a terminal-based text editor like Vim or its predecessor Vi, it’s quite common to make mistakes or change your mind about recent edits. Mastering the process of undoing and redoing changes is essential for editing files effectively. Both Vim and Vi offer robust mechanisms for reversing and reinstating modifications, which can save time and frustration.

TL;DR

In Vi and Vim, you can undo changes using the u key and redo changes using Ctrl + r (in Vim only). Vi doesn’t support multiple redo levels, while Vim maintains a detailed undo history. Undo branches in Vim can even let you jump through previous states like a versioning system. Know whether you’re using Vi or Vim, as capabilities differ.

Understanding the Basics: Normal Mode is the Key

Both Vi and Vim operate in different modes, the most commonly used one being Normal Mode, where you can execute commands such as save, undo, redo, and navigate. Before using any undo or redo commands, make sure you are in Normal Mode by pressing Esc several times to ensure you’re not in Insert or Visual Mode.

Undoing Changes

Undoing changes in Vim and Vi is a straightforward operation, but it functions differently in each. Here’s how to use it effectively:

• In Vim: Press u in Normal Mode to undo the last change. Pressing u repeatedly will undo earlier changes.
• In Vi: The ability to undo is often more limited. Typically, only the last change can be undone using u.

You can also undo changes line by line or all changes on a specific line using more refined commands:

• U — Restores the current line to its original state since the cursor moved to it (only in Vim).

For example, imagine editing a long configuration file and you accidentally delete a valuable block of text. Pressing u multiple times helps you roll back through previous states until you reach the desired version.

Redoing Changes in Vim

Redoing undone changes is possible only in Vim (not in traditional Vi). Vi lacks the redo feature as understood today.

To redo changes:

• Ctrl + r — Redoes the last undone operation. You can press Ctrl + r repeatedly to step forward through the undo history.

Redo is particularly useful when you’ve undone multiple steps and then decide you want to reinstate some of them. Instead of starting over, you can move forward through the change history with this command.

Undo Branches in Vim

Vim introduces a more advanced feature called Undo Branches. Imagine branching paths of editing history, similar to a commit tree in Git. You can use commands to navigate this history beyond the linear undo and redo functions.

• :undo — Jump to a specific undo state.
• :undolist — Displays a list of undo branches available.
• :earlier and :later — Move backward and forward through undo history based on time or number of changes.

For example:

:earlier 10m

This moves the file state back 10 minutes worth of changes.

Or:

:later 5

This re-applies 5 undo steps forward.

Previewing the Undo History

Want better insight into your editing session? Vim allows you to visualize the internal undo history with:

:undolist

This outputs a list of undo points and their corresponding numbers. You can then jump to a specific state using:

:undo {number}

This feature is ideal for power users who might want to navigate complex editing sessions carefully.

Customizing Vim’s Undo Behavior

Want to expand Vim’s power even more? By default, undo history is lost when the file is closed. However, you can enable persistent undo history with the following setting in your .vimrc file:

set undofile

You might also want to specify where undo files are stored:

set undodir=~/.vim/undo
set undofile

This way, when you return to a file later, Vim remembers your entire undo history. That’s especially useful in large projects.

Vi Limitations Compared to Vim

It’s important to note Vi’s capabilities are limited compared to Vim, especially regarding multiple undo steps and redo functionality. If you find yourself using Vi regularly, it may be worth checking whether you’re truly in Vi or Vim by typing:

:version

Vim will give you detailed version information, while Vi will either return an error or something much more limited.

Tips for Effective Undo and Redo Usage

Here are some handy tips to make the most out of Vim/Vi undo and redo functionalities:

• Press u to keep undoing previous changes.
• Redo what’s been undone using Ctrl + r — only available in Vim.
• Use :undolist to visualize undo branches.
• Customize your environment to keep undo history persistent across sessions.
• Press U to restore a full line to its original state since cursor arrival.

Conclusion

The ability to undo and redo changes in Vi and Vim is a game-changer for terminal-based editing workflows. While Vi provides only basic undo functionality, Vim expands the experience with multi-level undo, redo, and even undo branching. By learning these capabilities, users can navigate and refine their editing sessions with precision.

FAQ: Common Questions About Undo/Redo in Vim and Vi

• Can you redo in Vi?
  No, traditional Vi does not support a redo feature. You can only undo the last change.
• What’s the difference between u and U in Vim?
  u undoes recent changes step-by-step. U resets the current line to its original state (since the cursor was last on it).
• How do I save undo history across Vim sessions?
  Enable persistent undo by adding set undofile to your .vimrc and specifying the directory via set undodir.
• How can I visualize or manage undo history?
  Use :undolist to view the undo tree and :undo, :earlier, or :later to navigate variable undo/redo states.
• Which version of Vim supports persistent undo?
  Vim 7.3 and above supports persistent undo via the undofile setting.