An introduction to the vi editor

Plan Zero — Wed, 26 Aug 2009 18:34:37 +0000

Back in 2006 I wrote an article on the vi text editor. While I’m in the process of rearranging my site, the time seems right to republish the article. Read and enjoy!

The history of vi

The vi text editor originated at the University of California in Berkeley. Created by Bill Joy in 1976 as a replacement for the frustrating ed line editor, it was designed to be usable over a 300 or 1200 baud modem, and as such quickly evolved into a powerful yet light text editing application, cramming functionality into every keystroke.

In a 1999 interview talking about what inspired him to write vi, Bill Joy explains:

… we got frustrated with the editor we were using which was named ed. ed is certainly frustrating. We got this code from a guy named George Coulouris … called em – Editor for Mortals – since only immortals could use ed to do anything. So we modified em and created en. I don’t know if there was an eo or an ep but finally there was ex. [laughter] I remember en but I don’t know how it got to ex. So I had a terminal at home and a 300 baud modem so the cursor could move around and I just stayed up all night for a few months and wrote vi.

Why vi?

Despite its age, vi is still an important tool today. This is demonstrated by the fact that every unix/linux distribution released over the last twenty years is likely to have a copy installed by default. Since the original release of vi, many derivatives have been written (such as vim, vile and elvis), with usability and functionality added along the way. Because of this, vi is probably one of the most evolved and stable text editors in the world.

Many of the more recent vi clones are also intelligent enough to know about the type of document you are editing, and will help you out by automatically indenting your text (in the case of HTML or C, for example) or by highlighting the syntax to make your work much clearer. In the great Unix tradition, features that bug you or help you can be turned on and off at your preference, and spending a few minutes customising vi to your liking can save you hours of work in the long run.

Operation modes

Most common text editors have just one mode, and use a menu system or multiple key combinations to allow you to perform functions on your document, such as saving or searching and replacing text. The vi editor has two modes: insert mode, in which text is edited and entered, and command mode, where editing functions and document navigation take place. If this seems strange, don’t let it put you off; you’ll get used to the concept fairly quickly!

In command mode, you can tell vi to use any number of functions, from pasting text to quitting or opening up a shell. Most commands in vi are short, and many are single letters. Command mode is also where you enter insert mode. In insert mode, you can only enter text. Nothing more, with the exception of using the backspace key to go back and correct mistakes in the newly entered text. In insert mode you cannot copy and paste, search or save your document.

You will find yourself using both modes extensively in vi, and once you get the hang of using the two modes properly, you will see that you can edit documents much faster than you ever could using your current text editor. Personally, I use vi for almost all of my console-based text editing and coding, including to write this tutorial :-)

Using modes and adding text

Okay, enough theory, on to the useful stuff!

When you first fire up vi (by opening up a shell and typing vi), you will be presented with a screen that looks something like this:

~ ~ ~ ~ ~ ~

Each tilde represents a line with no content. The tildes are used to distinguish between a line with no content whatsoever, and a blank line; i.e. one with a newline character (what you get when you pressenter) but no visible text. When vi first starts up, you will be in command mode. It is important to note that commands in vi are case sensitive – a lower case i does not do the same thing as an upper case I at all!

To enter some text into the document, start off by typing i, which will put you into insert mode. Everything that you type from now on will be taken as text to be entered into the document. Try typing a few words and practice using the backspace key to modify and type over some of the text.

From insert mode, pressing the escape key will put you back into command mode. Play around with changing modes a few times until you get the hang of it. Now, to quit vi, make sure that you are in command mode, then type :q (colon q) and press enter. This probably won’t quit as expected, but will give you a warning about the document being unsaved. As we don’t want to save this document, we can force vi to enact a command without warnings by using the force command. Try typing: :q! (colon q exclamation mark) and pressing enter. The vi editor should now oblige and drop you back to the shell.

Navigating around

For those who are used to using the mouse to navigate around documents, you may find navigation in vi a little tricky at first, however the power of the vi navigation commands far outweigh the advantages of using a mouse. To try out some of the navigation methods, it may be best to open a file which already has some content, or to create one to mess around with. You can open an existing file by running vi [filename], or just fire up vi, enter insert mode and type a few lines of random words.

The navigation keys in vi are as follows:

h – left
j – down
k – up
l – right

Easy to remember, huh? Although most modern clones of vi will allow you to use the arrow keys to move around your document in addition to the keys above, it is always good to learn the “proper” navigation keys just in case you are stuck using a version of vi that doesn’t support these more familiar keys. The other advantage of learning and using the keys above is that you spend less time moving your hands away from the centre of the keyboard, thus increasing typing speed. Give it a go!

One of the more useful navigation methods in vi is the search function. When in command mode, simply type /

(forward slash, then the text you wish to search for) then enter and you will be taken directly to the first match forwards from your current position. To repeat the search forwards, simply type / and hit enter. Searching backwards is also easy; type ? instead of / in either of the previous commands. Note that all searches are case sensitive by default; if you want to turn this off, try :set ic before searching.

Something to note when using this search method is that certain characters have special meaning to vi. For example, the full stop character . means match any character. This means that when performing the search /192.168, the string 192.168.1.125 will be matched, but so will 1920168. You can escape these special characters by using a back slash (\). So, to find our first pattern and not the second, we would use /192\.168. For more information, search for regular expressions on Wikipedia or check out Starmerj’s indispensable RegExp Crib Sheet.

Editing text

To recap, when you first start up vi you are put into command mode. From here, you can enter insert mode by typing i and typing away to your heart’s content. But are there other ways of entering insert mode? And what about editing what you’ve written? From command mode, you have many options.

As we have already found out, typing i will put us into insert mode at the cursor position. There are also a few other ways of entering insert mode. For example, if you type I, you will enter insert mode at the beginning of the current line. By typing a you will start from the character to the right of the cursor, and by typing A you will start editing at the end of the current line. You can also open an blank line for text below the cursor by typing o and above the cursor by typing O. Give it a try!

You can delete text character by character by placing the cursor in front of the text to be deleted and typing x. To delete text in the other direction (similar to using the backspace key), type X. You can delete a whole line by typing dd, whilst typing dw will delete the next word, and the D command will delete from the cursor to the end of the line.

Deleted too much text? No problem! Just type u to undo the last action, or U to restore the current line. Some clones of vi support multiple levels of undo, so typing u multiple times will take you further back in the history of the document. Make sure you are familiar with the working of these undelete commands, as you will find yourself using them often!

Copying and pasting

The vi editor has advanced copy and paste support. Should you need the functionality, vi also makes available multiple named buffers for performing complex copy and paste actions, such as swapping segments of code around without the need to go to and fro multiple times.

As you may have guessed, there are several commands for copying text with vi. Typing yw will copy a word, yy will copy the current line, and y will copy from the cursor to the target motion. For example, to copy from the cursor position to the word blue further down the document, you can type y/blue and press enter, which uses the search syntax as described in the Navigating Around section to move the cursor to its final position. You can use almost any navigation command here!

Pasting the copied text couldn’t be easier; simply type p to place the text before the cursor, and P to place the text after the cursor. You can, of course, paste copied text multiple times, so this is a handy way of duplicating data.

Using named buffers isn’t much different from normal copying and pasting – to copy text into a named buffer, type x[action] where x is the buffer name (a-z), and action is one of the copy actions above, such as yy. To paste text from a named buffer, just type xp or xP, again where x is the name of the buffer. After a little practice, you’ll be able to copy and paste sans souris in your sleep :-)

Saving files

Now that you know how to open documents, add and edit text and navigate around, it’s probably a good time to learn how to save your masterpiece.

If you started up vi with a filename as a parameter (i.e. vi [filename]), simply typing :w will save the document as filename. If there is a problem writing to the file (such as the file being read-only) and you have the correct permissions, you can force an override by using the ! (exclamation mark) character, like this :w!.

If you want to save another copy of the current document (for example, as a backup), or if you started vi without a filename parameter, you can write to a specifically named file by typing :w [filename]. You can also save typing by using the magic % place-the-current-filename-here variable. For example, typing :w %.bak will save the current document as it’s current filename with the extension .bak.

To save and quit vi with one command, type either :x or :wq; they both have the same effect. Personally, I prefer the latter, as I find it too easy to confuse :q and :x otherwise. You can also use ZZ (no colon!) to save the current text and exit vi. Again, you can attempt to override any errors by using an exclamation mark at the end of the save command.

More navigation

As you may have noticed, there are often many ways of getting a job done in vi. Navigation is no exception, and here to prove it are a few more elegant ways of navigating around your document.

You will no doubt at some point want to edit large files. If scrolling through it line-by-line doesn’t appeal to your sense of fun, help is at hand! To scroll forwards one screen type ctrl-F and to go backwards one screen type ctrl-B. You can scroll half-pages by typing ctrl-D to go forwards, or ctrl-U to go backwards. To show one more line at the top of the screen, type ctrl-Y, and for one more line at the bottom type ctrl-E.

It’s also sometimes handy to be able to reposition the page in relation to the cursor. Typing z and then pressing enter will reposition the line with the cursor to the top of the screen. z. will reposition to the middle of the screen, and z- to the bottom of the screen. These functions can be a bit disorientating at first, but don’t let that put you off!

Yet another handy navigation feature, especially when programming, is the ability to jump to a specific line number within your text. You can do this by typing :[line number] (colon followed by the line number) and pressing enter. For example, typing :32 will jump to the beginning of line 32 of your code or text.

Seek and… replace

Did I mention that you can enter insert mode in over-type mode by typing R, or that you can replace a single character by typing r[character]? Well, now you know. But that isn’t what this part of the tutorial is about.

The search and replace mechanism in vi uses regular expressions and can be made to do some complicated things, such as replacing the second o in the first seven matches of the word potato, or replacing any word containing two Ps with the word parrot. As with the closely related search function mentioned in the Navigating around section, all search operations are case sensitive. Type :set ic to turn this off if it irritates you.

I won’t delve into the world of regular expressions fully here, as there is far too much to cover in this small space. Suffice it to say that if you can think of an operation involving replacement of text, you can probably do it in vi with a single regexp command.

Basic search and replace operations are fairly easy; typing :s/foo/bar will substitute the word foo with the word bar on the current line. You can specify which portion of the document to search by using :1,4s/foo/bar, which will replace any occurrences on lines 1-4 of the document. If you want to do a search and replace operation globally, :%s/chicken/dog will replace chicken with dog wherever it is written throughout the document, and is the same as typing :1,$s/chicken/dog, where the $ means last line.

If you’re a bit nervous about accidentally replacing too much text in your document, you can ask vi to prompt you before each replacement is made by adding the /c flag to the end of your search expression, like this :%s/abuot/about/c. To aid with clarity, you can also get vi to print back a copy of each line after it has been modified by adding the /p flag.

Finally, beware of special characters! As mentioned in the Navigating around section, some characters have a special meaning to vi. You can find out more on Wikipedia, or by using your favourite search engine. Just search for regular expressions, regex or regexp!

Fin

As I hope this tutorial has shown, vi is an immensely powerful text editor which has an wide range of uses to this day. With a little work and a lot of patience, you too can find the joy of vi! The door has been opened a crack; through it you have seen the tip of the iceberg.

Where you go from here is a choice I leave to you…

Plan Zero Blog » Tutorials