Vi: the ancestor

Vi was the first full-screen editor in existence. Vi is one of the main examples used by UNIX detractors, but also one of the main arguments of its defenders: while it is complicated to learn, it is also an extremely powerful tool once you get into the habit of using it. With a few keystrokes, a Vi user can move mountains, and other than Emacs, few text editors can make the same claims.

The version supplied with Mandrake Linux is in fact vim, for VI iMproved, but we will call it Vi throughout this chapter.

Insert mode, command mode, ex mode...

To begin using Vi we use the same sort of command line as we did with Emacs. So let us go back to our two files and type:

$ vi file1 file2

At this point, you find yourself in front of a window resembling Figure 4.4.

Figure 4.4. Starting position in VIM

Starting position in VIM

You are now in command mode in front of the first open file. In command mode, you cannot insert text into a file, so you must switch into insert mode.

  • a and i: to insert text after and before the cursor (A and I insert text at the end and at the beginning of the current line)

  • o and O : to insert text below and above the current line.

In insert mode, you will see the string --INSERT-- appear at the bottom of the screen (so you know which mode you are in). This is the only mode that will allow you to insert text. To return to command mode, press the Esc key.

In insert mode, you can use the Backspace and DEL keys to delete text as you go along. The arrow keys will allow you to move around within the text in Command mode and Insert mode. In command mode, there are also other key combinations which we will look at later.

ex mode is accessed by pressing the : key in command mode. : will appear at the bottom of the screen with the cursor positioned on it. Everything you type up to the Enter you press at the end will be considered by Vi to be an ex command. If you delete the command and the : you typed in, you will return to command mode and the cursor will go back to its original position.

To save changes to a file you type :w in command mode. If you want to save the contents of the buffer to another file, type :w <file_name>.

Handling buffers

To move, in the same buffer, from among the files whose names were passed on the command line, type :next to move to the next file and :prev to move to the previous file. You can also use :e <file_name>, allowing you either to change to the desired file if this is already open, or to open another file. You may also use completion.

As with Emacs, you can have several buffers displayed on the screen. To do this, use the :split command.

To change buffers, type Ctrl+w j to go to the buffer below or Ctrl+w k to go to the buffer above. You can also use the up and down arrow keys instead of j or k. The :close command hides a buffer and the :q command closes it.

You should be aware that if you try to hide or close a buffer without saving the changes, the command will not be carried out and Vi will display this message:

No write since last change (use ! to override)

In this case, do as you are told and type :q! or :close!.

Editing text and move commands

Apart from the Backspace and DEL keys in edit mode, Vi has many other commands for deleting, copying, pasting, and replacing text in command mode. All the commands shown here are in fact separated into two parts: the action to be performed and its effect. The action may be:

  • c: to replace (Change); the editor deletes the text requested and goes back into insert mode after this command

  • d: to delete (Delete)

  • y: to copy (Yank). We will look at this in the next section.

  • .: repeats last action.

The effect defines which group of characters the command acts upon.

  • h, j, k, l: one character left, down, up, right[11]

  • e, b, w: to the end, beginning of the current word and the beginning of the next word

  • ^, 0, $: to the first non-blank character of the current line, the beginning of the current line, and the end of current line

  • f<x>: to next occurrence of character <x>. For example, fe moves the cursor to the next occurrence of the character e

  • /<string>, ?<string>: to the next and previous occurrence of string or regexp <string>. For example, /foobar moves the cursor to the next occurrence of the word foobar.

  • {, }: to the beginning, to the end of current paragraph;

  • G, H: to end of file, to beginning of screen.

Each of these “effect” characters or move commands can be preceded by a repetition number. For G, (“Go”) this references the line number in the file. Based on this information, you can make all sorts of combinations.

Some examples:

  • 6b: moves 6 words backwards

  • c8fk: delete all text until the eighth occurrence of the character k then goes into insert mode

  • 91G: goes to line 91 of the file

  • d3$: deletes up to the end of the current line plus the next two lines.

While many of these commands are not very intuitive, the best method to remember the commands is to practice them. But you can see that the expression “move mountains with a few keys” is not much of an exaggeration.

Cut, copy, paste

Vi has a command that we have already seen for copying text: the y command. To cut text, simply use the d command. There are 27 memories or buffers for storing text: an anonymous memory and 26 memories named after the 26 lowercase letters of the alphabet.

To use the anonymous memory you enter the command as-is. So the command y12w will copy the 12 words after the cursor into anonymous memory [12]. Use d12w if you want to cut this area.

To use one of the 26 named memories, enter the sequence "<x> before the command, where <x> gives the name of the memory. Therefore, to copy the same 12 words into the memory k, you would write "ky12w, or "kd12w to cut them.

To paste the contents of the anonymous memory, use the commands p or P (for Paste), to insert text after or before the cursor. To paste the contents of a named memory, use "<x>p or "<x>P in the same way (for example "dp will paste the contents of memory d after the cursor).

Let us look at the example of Figure 4.5.

Figure 4.5. VIM, before copying the text block

VIM, before copying the text block

To carry out this action, we will:

  • recopy the first 6 words of the sentence into memory r (for example): "ry6w [13];

  • go into the buffer file2, which is located below: Ctrl+w j;

  • paste the contents of memory r before the cursor: "rp.

We get the expected result, as shown in Figure 4.6.

Figure 4.6. VIM, after having copied the text block

VIM, after having copied the text block

Searching for text is very simple: in command mode, you simply type / followed by the string to search for, and then press the Enter key. For example, /party will search for the string party from the current cursor position. Pressing n takes you to the next occurrence, and if you reach the end of the file, the search will start again from the beginning. To search backwards, use ? instead of /.

Quit Vi

The command to quit is :q (in fact, this command actually closes the active buffer, as we have already seen, but if it is the only buffer present, you quit Vi). There is a shortcut: most of the time you edit only one file. So to quit, you will use:

  • :wq to save changes and quit (a quicker solution is ZZ), or

  • :q! to quit without saving.

You should note that if you have several buffers, :wq will only write the active buffer and then close it.



[11] A shortcut for dl (delete one character forward) is x; a shortcut for dh is X; dd deletes the current line.

[12] But only if the cursor is positioned at the beginning of the first word!

[13] y6w literally means: “ Yank 6 words ”.