Learning the vi and Vim Editors

Eighth Edition

Power and Agility Beyond Just Text Editing

With Early Release ebooks, you get books in their earliest form — the authors’ raw and unedited content as they write — so you can take advantage of these technologies long before the official release of these titles.

Arnold Robbins and Elbert Hannah

Learning the vi and Vim Editors

by Arnold Robbins and Elbert Hannah

Copyright © 2021 Elbert Hannah and Arnold Robbins. All rights reserved.

Printed in the United States of America.

Published by O’Reilly Media, Inc., 1005 Gravenstein Highway North, Sebastopol, CA 95472.

O’Reilly books may be purchased for educational, business, or sales promotional use. Online editions are also available for most titles (http://oreilly.com). For more information, contact our corporate/institutional sales department: 800-998-9938 or corporate@oreilly.com.

- Acquisitions Editor: Amanda Quinn

- Development Editor: Gary O’Brien

- Production Editor: Kate Galloway

- Interior Designer: David Futato

- Cover Designer: Karen Montgomery

- Illustrator: O’Reilly Media, Inc.

- July 2008: Seventh Edition

- September 2021: Eighth Edition

Revision History for the Early Release

- 2020-08-06: First Release

See http://oreilly.com/catalog/errata.csp?isbn=9781492078807 for release details.

The O’Reilly logo is a registered trademark of O’Reilly Media, Inc. Learning the vi and Vim Editors, the cover image, and related trade dress are trademarks of O’Reilly Media, Inc.

While the publisher and the authors have used good faith efforts to ensure that the information and instructions contained in this work are accurate, the publisher and the authors disclaim all responsibility for errors or omissions, including without limitation responsibility for damages resulting from the use of or reliance on this work. Use of the information and instructions contained in this work is at your own risk. If any code samples or other technology this work contains or describes is subject to open source licenses or the intellectual property rights of others, it is your responsibility to ensure that your use thereof complies with such licenses and/or rights.

978-1-492-07880-7

Dedication

To my wife, Miriam, for your love, patience, and support.

Arnold Robbins, Sixth, Seventh and Eighth Editions

Chapter 1. The vi Text Editor

A note for Early Release readers

With Early Release ebooks, you get books in their earliest form — the author’s raw and unedited content as they write — so you can take advantage of these technologies long before the official release of these titles.

This will be the 1st chapter of the final book.

If you have comments about how we might improve the content and/or examples in this book, or if you notice missing material within this chapter, please reach out to the author at learning.vi.and.vim@gmail.com.

Unix[1] has a number of editors that can process the contents of text files, whether those files contain data, source code, or sentences. There are line editors, such as ed and ex, which display a line of the file on the screen; and there are screen editors, such as vi and Emacs, which display a part of the file on your terminal screen. Text editors based on the X Window System are also commonly available and popular. GNU Emacs provides multiple X windows, as does Vim through its gvim version.

vi is the most useful standard text editor on your system. Unlike Emacs, it is available in nearly identical form on every modern Unix system, thus providing a kind of text-editing lingua franca.[2] The same might be said of ed and ex, but screen editors are generally much easier to use. (So much so, in fact, that line editors have generally fallen into disuse.) With a screen editor, you can scroll the page, move the cursor, delete lines, insert characters, and more, while seeing the results of your edits as you make them. Screen editors are very popular, since they allow you to make changes as you read through a file, like you would edit a printed copy, only faster.

Note

vi is short for visual editor and is pronounced “vee-eye.” This is illustrated graphically in Figure 1-1.

Figure 1-1. Correct pronunciation of vi

To many beginners, vi looks unintuitive and cumbersome — instead of using special control keys for word processing functions and just letting you type normally, it uses all of the regular keyboard keys for issuing commands. When the keyboard keys are issuing commands, vi is said to be in command mode. You must be in a special insert mode before you can type actual text on the screen. In addition, there seem to be so many commands.

Once you start learning, however, you realize that vi is well designed. You need only a few keystrokes to tell vi to do complex tasks. As you learn vi, you learn shortcuts that transfer more and more of the editing work to the computer — where it belongs.

vi (like any text editor) is not a “what you see is what you get” word processor. If you want to produce formatted documents, you must type in codes that are used by another formatting program to control the appearance of the printed copy. If you want to indent several paragraphs, for instance, you put a code where the indent begins and ends. Formatting codes allow you to experiment with or change the appearance of your printed files, and, in many ways, they give you much more control over the appearance of your documents than a word processor. Unix supports the troff formatting package.[3] The TeX and LaTeX formatters are popular, commonly available alternatives.[4] In recent years, so-called mark up languages have seen a resurgence in popularity. Of note are MarkDown and AsciiDoc[5], although there are others as well.

Note

vi does support some simple formatting mechanisms. For example, you can tell it to automatically wrap when you come to the end of a line, or to automatically indent new lines. In addition, Vim provides automatic spellchecking.

As with any skill, the more editing you do, the easier the basics become, and the more you can accomplish. Once you are used to all the powers you have while editing with vi, you may never want to return to any “simpler” editor.

What are the components of editing? First, you want to insert text (a forgotten word or a new or missing sentence), and you want to delete text (a stray character or an entire paragraph). You also need to change letters and words (to correct misspellings or to reflect a change of mind about a term). You might want to move text from one place to another part of your file. And, on occasion, you want to copy text to duplicate it in another part of your file.

Unlike many word processors, vi’s command mode is the initial or “default” mode. Complex, interactive edits can be performed with only a few keystrokes. (And to insert raw text, you simply give any of the several “insert” commands and then type away.)

One or two characters are used for the basic commands. For example:

i

Insert

cw

Change word

Using letters as commands, you can edit a file with great speed. You don’t have to memorize banks of function keys or stretch your fingers to reach awkward combinations of keys. You never have to remove your hands from the keyboard, or mess around with multiple levels of menus! Most of the commands can be remembered by the letters that perform them, and nearly all commands follow similar patterns and are related to each other.

In general, vi commands:

- Are case-sensitive (uppercase and lowercase keystrokes mean different things; I is different from i).

- Are not shown (or “echoed”) on the screen when you type them.

- Do not require an ENTER after the command.

There is also a group of commands that echo on the bottom line of the screen. Bottom-line commands are preceded by different symbols. The slash (/) and the question mark (?) begin search commands, and are discussed in Chapter 3. A colon (:) begins all ex commands. ex commands are those used by the ex line editor. The ex editor is available to you when you use vi, because ex is the underlying editor and vi is really just its “visual” mode. ex commands and concepts are discussed fully in Chapter 5, but this chapter introduces you to the ex commands to quit a file without saving edits.

A Brief Historical Perspective

Before diving into all the ins and outs of vi, it will help to understand vi’s worldview of your environment. In particular, this will help you make sense of many of vi’s otherwise more obscure error messages, and also appreciate how Vim has evolved beyond the original vi.

vi dates back to a time when computer users worked on terminals connected via serial lines to central mini-computers. Hundreds of different kinds of terminals existed and were in use worldwide. Each one did the same kind of actions (clear the screen, move the cursor, etc.), but the commands needed to make them do these actions were different. In addition, the Unix system let you choose the characters to use for backspace, generating an interrupt signal, and other commands useful on serial terminals, such as suspending and resuming output. These facilities were (and still are) managed with the stty command.

The original UCB version of vi abstracted out the terminal control information from the code (which was hard to change) into a text-file database of terminal capabilities (which was easy to change), managed by the termcap library. In the early 1980s, System V introduced a binary terminal information database and terminfo library. The two libraries were largely functionally equivalent. In order to tell vi which terminal you had, you had to set the TERM environment variable. This was typically done in a shell startup file, such as .profile or .login.

The termcap library is no longer used. GNU/Linux and BSD systems use the ncurses library, which provides a compatible superset of the System V terminfo library’s database and capabilities.

Today, everyone uses terminal emulators in a graphical environment (such as Gnome Terminal). The system almost always takes care of setting TERM for you.

Note

You can use vi from a PC non-GUI console too, of course. This is very useful when doing system recovery work in single-user mode. There aren’t too many people left who would want to work this way on a regular basis, though.

For day-to-day use, it is likely that you will want to use a GUI version of vi, such as Vim. On a Microsoft Windows or Mac OS system, this will probably be the default. However, when you run vi (or some other screen editor of the same vintage) inside a terminal emulator, it still uses TERM and terminfo and pays attention to the stty settings. And using it inside a terminal emulator is just as easy a way to learn vi as any other.

Another important fact to understand about vi is that it was developed at a time when Unix systems were considerably less stable than they are today. The vi user of yesteryear had to be prepared for the system to crash at arbitrary times, and so vi included support for recovering files that were in the middle of being edited when the system crashed.[6] So, as you learn vi and see the descriptions of various problems that might occur, bear these historical developments in mind.

Opening and Closing Files

You can use vi to edit any text file. vi copies the file to be edited into a buffer (an area temporarily set aside in memory), displays the buffer (though you can see only one screenful at a time), and lets you add, delete, and change text. When you save your edits, vi copies the edited buffer back into a permanent file, replacing the old file of the same name. Remember that you are always working on a copy of your file in the buffer, and that your edits do not affect your original file until you save the buffer. Saving your edits is also called “writing the buffer,” or more commonly, “writing your file.”

Opening a File

vi is the Unix command that invokes the vi editor for an existing file or for a brand new file. The syntax for the vi command is:

$ vi [filename]

The brackets shown on the above command line indicate that the filename is optional. The brackets should not be typed. The $ is the shell prompt. If the filename is omitted, vi opens an unnamed buffer. You can assign the name when you write the buffer into a file. For right now, though, let’s stick to naming the file on the command line.

A filename must be unique inside its directory.

A filename can include any 8-bit character except a slash (/), which is reserved as the separator between files and directories in a pathname, and ASCII NUL, the character with all zero bits. You can even include spaces in a filename by typing a backslash (\) before the space. In practice, though, filenames generally consist of any combination of uppercase and lowercase letters, numbers, and the characters dot (.) and underscore (_). Remember that Unix is case-sensitive: lowercase letters are distinct from uppercase letters. Also remember that you must press ENTER to tell Unix that you are finished issuing your command.

When you want to open a new file in a directory, give a new filename with the vi command. For example, if you want to open a new file called practice in the current directory, you would enter:

$ vi practice

Since this is a new file, the buffer is empty and the screen appears as follows:

~
~
~
"practice" [New file]

The tildes (~) down the left-hand column of the screen indicate that there is no text in the file, not even blank lines. The prompt line (also called the status line) at the bottom of the screen echoes the name and status of the file.

You can also edit any existing text file in a directory by specifying its filename. Suppose that there is a Unix file with the pathname /home/john/letter. If you are already in the /home/john directory, use the relative pathname. For example:

$ vi letter

brings a copy of the file letter to the screen.

If you are in another directory, give the full pathname to begin editing:

$ vi /home/john/letter

Problems Opening Files

- When you invoke vi , the message [open mode] appears.
Your terminal type is probably incorrectly identified. Quit the editing session immediately by typing :q. Check the environment variable $TERM. It should be set to the name of your terminal. Or ask your system administrator to provide an adequate terminal type setting.

- You see one of the following messages:

Visual needs addressable cursor or upline capability
terminal: Unknown terminal type
Block device required
Not a typewriter

Your terminal type is either undefined, or there’s probably something wrong with your terminfo entry. Enter :q to quit. Check your $TERM environment variable, or ask your system administrator to select a terminal type for your environment.

- A [new file] message appears when you think a file already exists.
Check that you have used correct case in the filename (Unix filenames are case-sensitive). If you have, then you are probably in the wrong directory. Enter :q to quit. Then check to see that you are in the correct directory for that file (enter pwd at the Unix prompt). If you are in the right directory, check the list of files in the directory (with ls) to see whether the file exists under a slightly different name.

- You invoke vi , but you get a colon prompt (indicating that you’re in ex line-editing mode).
You probably typed an interrupt before vi could draw the screen. Enter vi by typing vi at the ex prompt (:).

- One of the following messages appears:

[Read only]
File is read only
Permission denied

“Read only” means that you can only look at the file; you cannot save any changes you make. You may have invoked vi in view mode (with view or vi -R), or you do not have write permission for the file. See the section “Problems Saving Files”.

- One of the following messages appears:

Bad file number
Block special file
Character special file
Directory
Executable
Non-ascii file
file non-ASCII

The file you’ve called up to edit is not a regular text file. Type :q! to quit, then check the file you wish to edit, perhaps with the file command.

- When you type :q because of one of the previously mentioned difficulties, this message appears:

No write since last change (:quit! overrides).

You have modified the file without realizing it. Type :q! to leave vi. Your changes from this session are not saved in the file.

Modus Operandi

As mentioned earlier, the concept of the current “mode” is fundamental to the way vi works. There are two modes, command mode and insert mode. You start out in command mode, where every keystroke represents a command. In insert mode, everything you type becomes text in your file.

Sometimes, you can accidentally enter insert mode, or conversely, leave insert mode accidentally. In either case, what you type will likely affect your files in ways you did not intend.

Press the ESC key to force vi to enter command mode. If you are already in command mode, vi beeps at you when you press the ESC key. (Command mode is thus sometimes referred to as “beep mode.”)

Once you are safely in command mode, you can proceed to repair any accidental changes, and then continue editing your text.

Saving and Quitting a File

You can quit working on a file at any time, save your edits, and return to the Unix prompt. The vi command to quit and save edits is ZZ. Note that ZZ is capitalized.

Let’s assume that you do create a file called practice to practice vi commands, and that you type in six lines of text. To save the file, first check that you are in command mode by pressing ESC, and then enter ZZ.

Keystrokes

Results

ZZ

"practice" [New file] 6 lines, 320 characters

Give the write and save command, ZZ. Your file is saved as a regular Unix file.

ls

ch01 ch02 practice

Listing the files in the directory shows the new file practice that you created.

You can also save your edits with ex commands. Type :w to save (write) your file but not quit vi; type :q to quit if you haven’t made any edits; and type :wq to both save your edits and quit. (:wq is equivalent to ZZ.) We’ll explain fully how to use ex commands in Chapter 5; for now, you should just memorize a few commands for writing and saving files.

Quitting Without Saving Edits

When you are first learning vi, especially if you are an intrepid experimenter, there are two other ex commands that are handy for getting out of any mess that you might create.

What if you want to wipe out all of the edits you have made in a session and then return to the original file? The command:

:e! ENTER

returns you to the last saved version of the file, so you can start over.

Suppose, however, that you want to wipe out your edits and then just quit vi? The command:

:q! ENTER

quits the file you’re editing and returns you to the Unix prompt. With both of these commands, you lose all edits made in the buffer since the last time you saved the file. vi normally won’t let you throw away your edits. The exclamation point added to the :e or :q command causes vi to override this prohibition, performing the operation even though the buffer has been modified.

Problems Saving Files

- You try to write your file, but you get one of the following messages:

File exists
File file exists - use w!
[Existing file]
File is read only

Type :w! file to overwrite the existing file, or type :w newfile to save the edited version in a new file.

- You want to write a file, but you don’t have write permission for it. You get the message “Permission denied.”
Use :w newfile to write out the buffer into a new file. If you have write permission for the directory, you can use mv to replace the original version with your copy of it. If you don’t have write permission for the directory, type :w pathname/file to write out the buffer to a directory in which you do have write permission (such as your home directory, or /tmp).

- You try to write your file, but you get a message telling you that the file system is full.
Type :!rm junkfile to delete a (large) unneeded file and free some space. (Starting an ex command with an exclamation point gives you access to Unix.)
Or type :!df to see whether there’s any space on another file system. If there is, choose a directory on that file system and write your file to it with :w pathname. (df is the Unix command to check a disk’s free space.)

- The system puts you into open mode and tells you that the file system is full.
The disk with vi’s temporary files is filled up. Type :!ls /tmp to see whether there are any files you can remove to gain some disk space.[7] If there are, create a temporary Unix shell from which you can remove files or issue other Unix commands. You can create a shell by typing :sh; type CTRL-D or exit to terminate the shell and return to vi. (All modern shells provide job-control, so you can simply type CTRL-Z to suspend vi and return to the Unix prompt; type fg to return to vi.) Once you’ve freed up some space, write your file with :w!.

- You try to write your file, but you get a message telling you that your disk quota has been reached.
Try to force the system to save your buffer with the ex command :pre (short for :preserve). If that doesn’t work, look for some files to remove. Use :sh (or CTRL-Z) to move out of vi and remove files. Use CTRL-D (or fg) to return to vi when you’re done. Then write your file with :w!.

Exercises

The only way to learn vi is to practice. You now know enough to create a new file and to return to the Unix prompt. Create a file called practice, insert some text, and then save and quit the file.

Open a file called practice in the current directory:

vi practice

Insert text:

iany text you like

Return to command mode:

ESC

Quit vi, saving edits:

ZZ

[1] These days, the term “Unix” includes both commercial systems derived from the original Unix code base, and Unix work-alikes whose source code is available. Solaris, AIX, and HP-UX are examples of the former, and GNU/Linux and the various BSD-derived systems are examples of the latter. Also included are Mac OS’s terminal environment, Windows Subsystem for Linux (WSL) on Windows 10, and Cygwin and other similar environments for Windows. Unless otherwise noted, everything in this book applies across the board to all those systems.

[2] GNU Emacs has become the universal version of Emacs. The only problem is that it doesn’t come standard with most commercial Unix systems; you must retrieve and install it yourself.

[3] troff is for laser printers and typesetters. Its “twin brother” is nroff, for line printers and terminals. Both accept the same input language. Following common Unix convention, we refer to both with the name troff. Today, anyone using troff uses the GNU version, groff. See http://www.gnu.org/software/groff/ for more information.

[4] See http://www.ctan.org and http://www.latex-project.org for information on TeX and LaTeX, respectively.

[5] For more information on these, see https://en.wikipedia.org/wiki/Markdown and http://asciidoc.org/, respectively.

[6] Thankfully, this kind of thing is much less common, although systems can still crash due to external circumstances, such as a power outage.

[7] Your vi may keep its temporary files in /usr/tmp, /var/tmp, or your current directory; you may need to poke around a bit to figure out where exactly you’ve run out of room. Vim generally keeps its temporary file in the same directory as the file being edited.

Chapter 2. Simple Editing

A note for Early Release readers

With Early Release ebooks, you get books in their earliest form — the author’s raw and unedited content as they write — so you can take advantage of these technologies long before the official release of these titles.

This will be the 2nd chapter of the final book.

If you have comments about how we might improve the content and/or examples in this book, or if you notice missing material within this chapter, please reach out to the author at learning.vi.and.vim@gmail.com.

This chapter introduces you to editing with vi, and it is set up to be read as a tutorial. In it you will learn how to move the cursor and how to make some simple edits. If you’ve never worked with vi, you should read the entire chapter.

Later chapters show you how to expand your skills to perform faster and more powerful edits. One of the biggest advantages for an adept user of vi is that there are so many options to choose from. (One of the biggest disadvantages for a newcomer to vi is that there are so many different editor commands.)

You can’t learn vi by memorizing every single vi command. Start out by learning the basic commands introduced in this chapter. Note the patterns of use that the commands have in common.

As you learn vi, be on the lookout for more tasks that you can delegate to the editor, and then find the command that accomplishes it. In later chapters you will learn more advanced features of vi, but before you can handle the advanced, you must master the simple.

This chapter covers:

- Moving the cursor

- Adding and changing text

- Deleting, moving, and copying text

- More ways to enter insert mode

vi Commands

vi has two modes: command mode and insert mode. As soon as you enter a file, you are in command mode, and the editor is waiting for you to enter a command. Commands enable you to move anywhere in the file, to perform edits, or to enter insert mode to add new text. Commands can also be given to exit the file (saving or ignoring your edits) in order to return to the Unix prompt.

You can think of the different modes as representing two different keyboards. In insert mode, your keyboard functions regularly. In command mode, each key has a new meaning or initiates some instruction.

There are several ways to tell vi that you want to begin insert mode. One of the most common is to press i. The i doesn’t appear on the screen, but after you press it, whatever you type does appear on the screen and is entered into the buffer. The cursor marks the current insertion point.[1] To tell vi that you want to stop inserting text, press ESC. Pressing ESC moves the cursor back one space (so that it is on the last character you typed) and returns vi to command mode.

For example, suppose you have opened a new file and want to insert the word “introduction.” If you type the keystrokes iintroduction, what appears on the screen is:

introduction

When you open a new file, vi starts in command mode and interprets the first keystroke (i) as the insert command. All keystrokes made after the insert command are considered text until you press ESC. If you need to correct a mistake while in insert mode, backspace and type over the error. Depending on your terminal and its settings, backspacing may erase what you’ve previously typed or may just back up over it. In either case, whatever you back up over is deleted. Note that you can’t use the backspace key to back up beyond the point where you entered insert mode. (If you have disabled vi compatibility, Vim allows you to backspace beyond the point where you entered insert mode.)

vi has an option that lets you define a right margin and provides a carriage return automatically when you reach it. For right now, while you are inserting text, press ENTER to break the lines.

Sometimes you don’t know whether you are in insert mode or command mode. Whenever vi does not respond as you expect, press ESC once or twice to check which mode you are in. When you hear the beep, you are in command mode.

Moving the Cursor

You may spend only a small amount of time in an editing session adding new text in insert mode; much of the time you will be making edits to existing text.

In command mode you can position the cursor anywhere in the file. Since you begin all basic edits (changing, deleting, and copying text) by placing the cursor at the text that you want to change, you want to be able to move the cursor to that place as quickly as possible.

There are vi commands to move the cursor:

- Up, down, left, or right — one character at a time

- Forward or backward by blocks of text such as words, sentences, or paragraphs

- Forward or backward through a file, one screen at a time

In Figure 2-1, an underscore marks the present cursor position. Circles show movement of the cursor from its current position to the position that would result from various vi commands.

Figure 2-1. Sample movement commands

Single Movements

The keys h, j, k, and l, right under your fingertips, move the cursor:

h

Left, one space

j

Down, one line

k

Up, one line

l

Right, one space

You can also use the cursor arrow keys (←, ↓, ↑, →), + and - to go up and down, CTRL-P and CTRL-N to also go up and down, or the ENTER and BACKSPACE keys, but they are out of the way.

At first, it may seem awkward to use letter keys instead of arrows for cursor movement. After a short while, though, you’ll find it is one of the things you’ll like best about vi — you can move around without ever taking your fingers off the center of the keyboard.

Before you move the cursor, press ESC to make sure that you are in command mode. Use h, j, k, and l to move forward or backward in the file from the current cursor position. When you have gone as far as possible in one direction, you hear a beep and the cursor stops. For example, once you’re at the beginning or end of a line, you cannot use h or l to wrap around to the previous or next line; you have to use j or k.[2] Similarly, you cannot move the cursor past a tilde (~) representing a line without text, nor can you move the cursor above the first line of text.

Numeric Arguments

You can precede movement commands with numbers. Figure 2-2 shows how the command 4l moves the cursor four character positions to the right, just as if you had typed l four times (llll).

Figure 2-2. Multiplying commands by numbers

The ability to multiply commands gives you more options and power for each command you learn. Keep this in mind as we introduce additional commands.

Movement Within a Line

When you saved the file practice, vi displayed a message telling you how many lines are in that file. A line is not necessarily the same length as the visible line (often limited to 80 characters) that appears on the screen. A line is any text entered between newlines. (A newline character is inserted into the file when you press the ENTER key in insert mode.) If you type 200 characters before pressing ENTER, vi regards all 200 characters as a single line (even though those 200 characters visibly take up several lines on the screen).

As we mentioned in Chapter 1, The vi Text Editor, vi has an option that allows you to set a distance from the right margin at which vi automatically inserts a newline character. This option is wrapmargin (its abbreviation is wm). You can set a wrapmargin at 10 characters:

:set wm=10

This command doesn’t affect lines that you’ve already typed. We’ll talk more about setting options in Chapter 7. (This one really couldn’t wait!)

If you do not use vi’s automatic wrapmargin option, you should break lines with carriage returns to keep the lines of manageable length.

Two useful commands that involve movement within a line are:

0 (digit zero)

Move to beginning of line.

$

Move to end of line.

In the following example, line numbers are displayed. (Line numbers can be displayed in vi by using the number option, which is enabled by typing :set nu in command mode. This operation is described in Chapter 7.)

1  With a screen editor you can scroll the page,
2  move the cursor, delete lines, insert characters,
and more, while seeing the results of your edits
as you make them.
3  Screen editors are very popular.

The number of logical lines (3) does not correspond to the number of visible lines (5) that you see on the screen. If the cursor were positioned on the d in the word delete, and you entered $, the cursor would move to the period following the word them. If you entered 0, the cursor would move back to the letter m in the word move, at the beginning of line two.

Movement by Text Blocks

You can also move the cursor by blocks of text: words, sentences, paragraphs, etc.

w

Move forward one word (alphanumeric characters make up words)

W

Move forward one Word (white space separates words)

b

Move backward one word (alphanumeric characters make up words)

B

Move backward one Word (white space separates words)

G

Go to a specific line

The w command moves the cursor forward one word at a time, counting symbols and punctuation as equivalent to words. The following line shows cursor movement by w:

cursor, delete lines, insert characters,

You can also move by word, not counting symbols and punctuation, using the W command. (You can think of this as a “large” or “capital” Word.)

Cursor movement using W looks like this:

cursor, delete lines, insert characters,

To move backward by word, use the b command. Capital B allows you to move backward by word, not counting punctuation.

As mentioned previously, movement commands take numeric arguments; so, with either the w or b commands you can multiply the movement with numbers. 2w moves forward two words; 5B moves back five words, not counting punctuation.

To move to a specific line, you can use the G command. Plain G goes to the end of the file, 1G goes to the top of the file, and 42G goes to line 42. This is described in more detail later in the section “The G (Go To) Command.”

We discuss movement by sentences and by paragraphs in Chapter 3. For now, practice using the cursor movement commands that you know, combining them with numeric multipliers.

Simple Edits

When you enter text in your file, it is rarely perfect. You find typos or want to improve on a phrase; sometimes your program has a bug. Once you enter text, you have to be able to change it, delete it, move it, or copy it. Figure 2-3 shows the kinds of edits you might want to make to a file. The edits are indicated by proofreading marks.

Figure 2-3. Proofreading edits

In vi you can perform any of these edits with a few basic keystrokes: i for insert (which you’ve already seen); a for append; c for change; and d for delete. To move or copy text, you use pairs of commands. You move text with a d for “delete,” then a p for “put”; you copy text with a y for “yank,” then a p for “put.” You may also use x to delete a single character, and r to replace a single character. Each type of edit is described in this section. Figure 2-4 shows the vi commands you use to make the edits marked in Figure 2-3.

Figure 2-4. Edits with vi commands

Inserting New Text

You have already seen the insert command (i) used to enter text into a new file. You also use the insert command while editing existing text to add missing characters, words, and sentences. In the file practice, suppose you have the sentence:

you can scroll
the page, move the cursor, delete
lines, and insert characters.

with the cursor positioned as shown. To insert With a screen editor at the beginning of the sentence, enter the following:

Keystrokes

Results

2k

you can scroll the page, move the cursor, delete lines, and insert characters.

Move the cursor up two lines with the k command, to the line where you want to make the insertion.

iWith a

With a you can scroll the page, move the cursor, delete lines, and insert characters.

Press i to enter insert mode and begin inserting text.

screen editor ESC

With a screen editor you can scroll the page, move the cursor, delete lines, and insert characters.

Finish inserting text, and press ESC to end the insert and return to command mode.

Appending Text

You can append text at any place in your file with the append command, a. This works in almost the same way as i, except that text is inserted after the cursor rather than before the cursor. You may have noticed that when you press i to enter insert mode, the cursor doesn’t move until after you enter some text. By contrast, when you press a to enter insert mode, the cursor moves one space to the right. When you enter text, it appears after the original cursor position.

Changing Text

You can replace any text in your file with the change command, c. To tell c how much text to change, you combine c with a movement command. In this way, a movement command serves as a text object for the c command to affect. For example, c can be used to change text from the cursor:

cw

To the end of a word

c2b

Back two words

c$

To the end of the line

c0

To the beginning of the line

After issuing a change command, you can replace the identified text with any amount of new text, with no characters at all, with one word, or with hundreds of lines. c, like i and a, leaves you in insert mode until you press the ESC key.

When the change affects only the current line, vi marks the end of the text to be changed with a $, so that you can see what part of the line is affected. (See the example for cw, next.)

Words

To change a word, combine the c (change) command with w for word. You can replace a word (cw) with a longer or shorter word (or any amount of text). cw can be thought of as “delete the word marked and insert new text until ESC is pressed.”

Suppose you have the following line in your file practice:

With an editor you can scroll the page,

and want to change an to a screen. You need to change only one word:

Keystrokes

Results

w

With an editor you can scroll the page,

Move with w to the place you want the edit to begin.

cw

With a$ editor you can scroll the page,

Give the change word command. The end of the text to be changed is marked with a $ (dollar sign).

a screen

With a screen editor you can scroll the page,

Type in the replacement text, and then press ESC to return to command mode.

cw also works on a portion of a word. For example, to change spelling to spelled, you can position the cursor on the i, type cw, then type ed, and finish with ESC.

General Form of vi Commands

In the change commands we’ve mentioned up to this point, you may have noticed the following pattern:

(command)(text object)

command is the change command c, and text object is a movement command (you don’t type the parentheses). But c is not the only command that requires a text object. The d command (delete) and the y command (yank) follow this pattern as well.

Remember also that movement commands take numeric arguments, so numbers can be added to the text objects of c, d, and y commands. For example, d2w and 2dw are commands to delete two words. With this in mind, you can see that most vi commands follow a general pattern:

(command)(number)(text object)

or the equivalent form:

(number)(command)(text object)

Here’s how this works. number and command are optional. Without them, you simply have a movement command. If you add a number, you have a multiple movement. On the other hand, combine a command (c, d, or y) with a text object to get an editing command.

When you realize how many combinations are possible in this way, vi becomes a powerful editor indeed!

Lines

To replace the entire current line, use the special change command, cc. cc changes an entire line, replacing that line with any amount of text entered before pressing ESC. It doesn’t matter where the cursor is located on the line; cc replaces the entire line of text.

A command like cw works differently from a command like cc. In using cw, the old text remains until you type over it, and any old text that is left over (up to the $) goes away when you press ESC. In using cc, though, the old text is wiped out first, leaving you a blank line on which to insert text.

The “type over” approach happens with any change command that affects less than a whole line, whereas the “blank line” approach happens with any change command that affects one or more lines.

C replaces characters from the current cursor position to the end of the line. It has the same effect as combining c with the special end-of-line indicator $ (c$).

The commands cc and C are really shortcuts for other commands, so they don’t follow the general form of vi commands. You’ll see other shortcuts when we discuss the delete and yank commands.

Characters

One other replacement edit is given by the r command. r replaces a single character with another single character. You do not have to press ESC to return to command mode after making the edit. There is a misspelling in the line below:

Pith a screen editor you can scroll the page,

Only one letter needs to be corrected. You don’t want to use cw in this instance because you would have to retype the entire word. Instead, use r to replace the single character at the cursor:

Keystrokes

Results

rW

With a screen editor you can scroll the page,

Give the replace command r, followed by the replacement character W.

Substituting text

Suppose you want to change just a few characters, and not a whole word. The substitute command (s), by itself, replaces a single character. With a preceding count, you can replace that many characters. As with the change command (c), the last character of the text is marked with a $ so that you can see how much text will be changed.

The S command, as is usually the case with uppercase commands, lets you change whole lines. In contrast to the C command, which changes the rest of the line from the current cursor position, the S command deletes the entire line, no matter where the cursor is. vi puts you in insert mode at the beginning of the line. A preceding count replaces that many lines.

Both s and S put you in insert mode; when you are finished entering new text, press ESC.

The R command, like its lowercase counterpart, replaces text. The difference is that R simply enters overstrike mode. The characters you type replace what’s on the screen, character by character, until you type ESC. You can overstrike a maximum of only one line; when you type ENTER, vi opens a new line, effectively putting you into insert mode.

Changing Case

Changing the case of a letter is a special form of replacement. The tilde (~) command changes a lowercase letter to uppercase or an uppercase letter to lowercase. Position the cursor on the letter whose case you want to change, and type a ~. The case of the letter changes, and the cursor moves to the next character.

In older versions of vi, you cannot specify a numeric prefix or text object for the ~ to affect. Modern versions do allow a numeric prefix.

If you want to change the case of more than one line at a time, you must filter the text through a Unix command such as tr, as described in Chapter 7.

Deleting Text

You can also delete any text in your file with the delete command, d. Like the change command, the delete command requires a text object (the amount of text to be operated on). You can delete by word (dw), by line (dd and D), or by other movement commands that you will learn later.

With all deletions, you move to where you want the edit to take place, then give the delete command (d) and the text object, such as w for word.

Words

Suppose you have the following text in the file:

Screen editors are are very popular,
since they allowed you to make
changes as you read through a file.

with the cursor positioned as shown. You want to delete one are in the first line:

Keystrokes

Results

2w

Screen editors are are very popular, since they allowed you to make changes as you read through a file.

Move the cursor to where you want the edit to begin (are).

dw

Screen editors are very popular, since they allowed you to make changes as you read through a file.

Give the delete word command (dw) to delete the word are.

dw deletes a word beginning where the cursor is positioned. Notice that the space following the word is deleted.

dw can also be used to delete a portion of a word. In this example:

since they allowed you to make

you want to delete the ed from the end of allowed.

Keystrokes

Results

dw

since they allowyou to make

Give the delete word command (dw) to delete the word, beginning with the position of the cursor.

dw always deletes the space before the next word on a line, but we don’t want to do that in this example. To retain the space between words, use de, which deletes only to the end of a word. Typing dE deletes to the end of a word, including punctuation.

You can also delete backward (db) or to the end or beginning of a line (d$ or d0).

Lines

The dd command deletes the entire line that the cursor is on. dd does not delete part of a line. Like its complement, cc, dd is a special command. Using the same text as in the previous example, with the cursor positioned on the first line as shown here:

Screen editors are very popular,
since they allow you to make
changes as you read through a file.

you can delete the first two lines:

Keystrokes

Results

2dd

changes as you read through a file.

Give the command to delete two lines (2dd). Note that even though the cursor was not positioned on the beginning of the line, the entire line is deleted.

The D command deletes from the cursor position to the end of the line. (D is a shortcut for d$.) For example, with the cursor positioned as shown:

Screen editors are very popular,
since they allow you to make
changes as you read through a file.

you can delete the portion of the line to the right of the cursor:

Keystrokes

Results

D

Screen editors are very popular, since they allow you to make changes

Give the command to delete the portion of the line to the right of the cursor (D).

Characters

Often you want to delete only one or two characters. Just as r is a special change command to replace a single character, x is a special delete command to delete a single character. x deletes only the character the cursor is on. In the line here:

zYou can move text by deleting text and then

you can delete the letter z by pressing x.[3] A capital X deletes the character before the cursor. Prefix either of these commands with a number to delete that number of characters. For example, 5x deletes the five characters under and to the right of the cursor.

Problems with deletions

- You’ve deleted the wrong text and you want to get it back.
There are several ways to recover deleted text. If you’ve just deleted something and you realize you want it back, simply type u to undo the last command (for example, a dd). This works only if you haven’t given any further commands, since u undoes only the most recent command. Alternatively, a U restores the line to its pristine state, the way it was before any changes were applied to it.
You can still recover a recent deletion, however, by using the p command, since vi saves the last nine deletions in nine numbered deletion buffers. If you know, for example, that the third deletion back is the one you want to restore, type:

"3p

to “put” the contents of buffer number 3 on the line below the cursor.
This works only for a deleted line. Words, or a portion of a line, are not saved in a buffer. If you want to restore a deleted word or line fragment, and u won’t work, use the p command by itself. This restores whatever you’ve last deleted. The next few subsections talk more about the commands u and p.
Note that Vim supports “infinite” undo, which makes life much easier. See the section “Undoing Undos” for more information.

Moving Text

In vi, you move text by deleting it and then placing that deleted text elsewhere in the file, like a “cut and paste.” Each time you delete a text block, that deletion is temporarily saved in a special buffer. Move to another position in your file and use the put command (p) to place that text in the new position. You can move any block of text, although moving is more useful with lines than with words.

The put command (p) puts the text that is in the buffer after the cursor position. The uppercase version of the command, P, puts the text before the cursor. If you delete one or more lines, p puts the deleted text on a new line(s) below the cursor. If you delete less than an entire line, p puts the deleted text into the current line, after the cursor.

Suppose in your file practice you have the text:

You can move text by deleting it and then,
like a "cut and paste,"
placing the deleted text elsewhere in the file.
each time you delete a text block.

and you want to move the second line, like a “cut and paste,” below the third line. Using delete, you can make this edit:

Keystrokes

Results

dd

You can move text by deleting it and then, placing the deleted text elsewhere in the file. each time you delete a text block.

With the cursor on the second line, delete that line. The text is placed in a buffer (reserved memory).

p

You can move text by deleting it and then, placing that deleted text elsewhere in the file. like a "cut and paste" each time you delete a text block.

Give the put command, p, to restore the deleted line at the next line below the cursor. To finish reordering this sentence, you would also have to change the capitalization and punctuation (with r) to match the new structure.

Note

Once you delete text, you must restore it before the next change command or delete command. If you make another edit that affects the buffer, your deleted text will be lost. You can repeat the put over and over, so long as you don’t make a new edit. In Chapter 4, you will learn how to save text you delete in a named buffer so that you can retrieve it later.

Transposing two letters

You can use xp (delete character and put after cursor) to transpose two letters. For example, in the word mvoe, the letters vo are transposed (reversed). To correct a transposition, place the cursor on v and press x, then p. By coincidence, the word transpose helps you remember the sequence xp; x stands for trans, and p stands for pose.

There is no command to transpose words. The section “More Examples of Mapping Keys” discusses a short sequence of commands that transposes two words.

Copying Text

Often you can save editing time (and keystrokes) by copying a part of your file to use in other places. With the two commands y (for yank) and p (for put), you can copy any amount of text and put that copied text in another place in the file. A yank command copies the selected text into a special buffer, where it is held until another yank (or deletion) occurs. You can then place this copy elsewhere in the file with the put command.

As with change and delete, the yank command can be combined with any movement command (yw, y$, 4yy). Yank is most frequently used with a line (or more) of text, because to yank and put a word usually takes longer than simply to insert the word.

The shortcut yy operates on an entire line, just as dd and cc do. But the shortcut Y, for some reason, does not operate the way D and C do. Instead of yanking from the current position to the end of the line, Y yanks the whole line; that is, Y does the same thing as yy.

Suppose you have in your file practice the text:

With a screen editor you can
scroll the page.
move the cursor.
delete lines.

You want to make three complete sentences, beginning each with With a screen editor you can. Instead of moving through the file, making this edit over and over, you can use a yank and put to copy the text to be added.

Keystrokes

Results

yy

With ascreen editor you can scroll the page. move the cursor. delete lines.

Yank the line of text that you want to copy into the buffer. The cursor can be anywhere on the line you want to yank (or on the first line of a series of lines).

2j

With a screen editor you can scroll the page. move the cursor. delete lines.

Move the cursor to where you want to put the yanked text.

P

With a screen editor you can scroll the page. With a screen editor you can move the cursor. delete lines.

Put the yanked text above the cursor line with P.

jp

With a screen editor you can scroll the page. With a screen editor you can move the cursor. With a screen editor you can delete lines.

Move the cursor down a line. Then put the yanked text below the cursor’s line with p.

Yanking uses the same buffer as deleting. Each new deletion or yank replaces the previous contents of the yank buffer. As we’ll see in Chapter 4, up to nine previous yanks or deletions can be recalled with put commands. You can also yank or delete directly into up to 26 named buffers, which allows you to juggle multiple text blocks at once.

Repeating or Undoing Your Last Command

Each edit command that you give is stored in a temporary buffer until you give the next command. For example, if you insert the after a word in your file, the command used to insert the text, along with the text that you entered, is temporarily saved.

Repeat

Any time you make the same editing command over and over, you can save time by duplicating it with the repeat command, the period (.). Position the cursor where you want to repeat the editing command, and type a period.

Suppose you have the following lines in your file:

With a screen editor you can
scroll the page.
With a screen editor you can
move the cursor.

You can delete one line, and then, to delete another line, simply type a period.

Keystrokes

Results

dd

With a screen editor you can scroll the page. move the cursor.

Delete a line with the command dd.

.

With a screen editor you can scroll the page.

Repeat the deletion.

Undo

As mentioned earlier, you can undo your last command if you make an error. Simply press u. The cursor need not be on the line where the original edit was made.

To continue the previous example, showing deletion of lines in the file practice:

Keystrokes

Results

u

With a screen editor you can scroll the page. move the cursor.

u undoes the last command and restores the deleted line.

U, the uppercase version of u, undoes all edits on a single line, as long as the cursor remains on that line. Once you move off a line, you can no longer use U.

Note that you can undo your last undo with u, toggling between two versions of text. u also undoes U, and U undoes any changes to a line, including those made with u.

Tip

A tip: the fact that u can undo itself leads to a nifty way to get around in a file. If you ever want to get back to the site of your last edit, simply undo it. You will pop back to the appropriate line. When you undo the undo, you’ll stay on that line.

Vim lets you use CTRL-R to “redo” an undone operation. Combined with infinite undo, you can move backward and forward through the history of changes to your file. See the section “Undoing Undos” for more information.

More Ways to Insert Text

You have inserted text before the cursor with the sequence:

itext to be inserted ESC

You’ve also inserted text after the cursor with the a command. Here are some other insert commands for inserting text at different positions relative to the cursor (some were discussed earlier):

A

Append text to the end of the current line.

I

Insert text at the beginning of the current line.

o (lowercase letter “o”)

Open an empty line below the cursor for text.

O (uppercase letter “o”)

Open an empty line above the cursor for text.

s

Delete the character at the cursor and substitute text.

S

Delete the current line and substitute text.

R

Starting at the cursor, overstrike existing characters with new characters.

All of these commands place you in insert mode. After inserting text, remember to press ESC to return to command mode.

A (append) and I (insert) save you from having to move your cursor to the end or beginning of the line before invoking insert mode. (The A command saves one keystroke over $a. Although one keystroke might not seem like much of a saving, the more adept — and impatient — an editor you become, the more keystrokes you will want to omit.)

o and O (open) save you from having to insert a carriage return. You can type these commands from anywhere within the line.

s and S (substitute) allow you to delete a character or a whole line and replace the deletion with any amount of new text. s is the equivalent of the two-stroke command c SPACE, and S is the same as cc. One of the best uses for s is to change one character to several characters.

R (“large” replace) is useful when you want to start changing text, but you don’t know exactly how much. For example, instead of guessing whether to say 3cw or 4cw, just type R and then enter your replacement text.

Numeric Arguments for Insert Commands

Except for o and O, the insert commands just listed (plus i and a) take numeric prefixes. With numeric prefixes, you might use the commands i, I, a, and A to insert a row of underlines or alternating characters. For example, typing 50i* ESC inserts 50 asterisks, and typing 25a*- ESC appends 50 characters (25 pairs of asterisk and hyphen). It’s better to repeat only a small string of characters.

With a numeric prefix, r replaces that number of characters with a repeated instance of a single character. For example, in C or C++ code, to change || to &&, you would place the cursor on the first pipe character and type 2r&.

You can use a numeric prefix with S to substitute several lines. It’s quicker and more flexible, though, to use c with a movement command.

A good case for using the s command with a numeric prefix is when you want to change a few characters in the middle of a word. Typing r wouldn’t be correct, and typing cw would change too much text. Using s with a numeric prefix is about the same as typing R.

There are other combinations of commands that work naturally together. For example, ea is useful for appending new text to the end of a word. It helps to train yourself to recognize such useful combinations so that they become automatic.

Joining Two Lines with J

Sometimes while editing a file you end up with a series of short lines that are difficult to scan. When you want to merge two lines into one, position the cursor anywhere on the first line, and press J to join the two lines.

Suppose your file practice reads:

With a
screen editor
you can
scroll the page, move the cursor

Keystrokes

Results

J

With a screen editor you can scroll the page, move the cursor

J joins the line the cursor is on with the line below.

.

With a screen editor you can scroll the page, move the cursor

Repeat the last command (J) with the . to join the next line with the current line.

Using a numeric argument with J joins that number of consecutive lines. In the example here, you could have joined three lines by using the command 3J.

Problems with vi Commands

- When you type commands, text jumps around on the screen and nothing works the way it’s supposed to.
Make sure you’re not typing the J command when you mean j.
You may have hit the CAPS LOCK key without noticing it. vi is case-sensitive; that is, uppercase commands (I, A, J, etc.) are different from lowercase commands (i, a, j), and if you hit this key, all your commands are interpreted not as lowercase but as uppercase commands. Press the CAPS LOCK key again to return to lowercase, press ESC to ensure that you are in command mode, and then type either U to restore the last line changed or u to undo the last command. You’ll probably also have to do some additional editing to fully restore the garbled part of your file.

Mode Indicators

As you know by now, vi has two modes — command mode and insert mode. Usually, you can’t tell by looking at the screen which mode you’re in. Furthermore, it’s often useful to know where in the file you are, without having to use the ^G or ex := commands.

Two options address these issues: showmode and ruler. Vim has both, while the “Heirloom” and Solaris /usr/xpg7/bin versions of vi have the showmode option.

Table 2-1 lists the special features in each editor.

Table 2-1. Position and mode indicators

Editor

With ruler, displays

With showmode, displays

vi

N/A

Separate mode indicators for open, input, insert, append, change, replace, replace one character, and substitute modes

Vim

Row and column

Insert, replace, and visual mode indicators mode indicators

Review of Basic vi Commands

Table 2-2 presents a few of the commands you can perform by combining the commands c, d, and y with various text objects. The last two rows show additional commands for editing. Table 2-3 and Table 2-4 list some other basic commands. Table 2-5 summarizes the rest of the commands described in this chapter.

Table 2-2. Edit commands

Text object

Change

Delete

Copy

One word

cw

dw

yw

Two words, not counting punctuation

2cW or c2W

2dW or d2W

2yW or y2W

Three words back

3cb or c3b

3db or d3b

3yb or y3b

One line

cc

dd

yy or Y

To end of line

c$ or C

d$ or D

y$

To beginning of line

c0

d0

y0

Single character

r

x or X

yl or yh

Five characters

5s

5x

5yl

Table 2-3. Movement

Movement

Commands

←, ↓, ↑, →

h, j, k, l

←, ↓, ↑, →

BACKSPACE, CTRL-N and ENTER, CTRL-P, space bar

To first character of next line

+

To first character of previous line

-

To end of word

e or E

Forward by word

w or W

Backward by word

b or B

To end of line

$

To beginning of line

0

Table 2-4. Other operations

Operations

Commands

Place text from buffer

p or P

Start vi, open file if specified

vi file

Save edits, quit file

ZZ

No saving of edits, quit file

:q! ENTER

Table 2-5. Text creation and manipulation commands

Editing action

Command

Insert text at current position

i

Insert text at beginning of line

I

Append text at current position

a

Append text to end of line

A

Open new line below cursor for new text

o

Open new line above cursor for new text

O

Delete line and substitute text

S

Overstrike existing characters with new text

R

Join current and next line

J

Toggle case

~

Repeat last action

.

Undo last change

u

Restore line to original state

U

You can get by in vi using only the commands listed in these tables. However, in order to harness the real power of vi (and increase your own productivity), you will need more tools. The following chapters describe those tools.

[1] Some versions show that you’re in input mode in the status line. This is discussed in the section “Mode Indicators”.

[2] Vim, with nocompatible set, allows you to “space past” the end of the line to the next one with l or the space bar.

[3] The mnemonic for x is that it is supposedly like “x-ing out” mistakes with a typewriter. Of course, who uses a typewriter anymore?

About the Authors

Arnold Robbins, an Atlanta native, is a professional programmer and technical author. He is also a happy husband, the father of four wonderful children, and an amateur Talmudist (Babylonian and Jerusalem). Since late 1997, he and his family have been living in Israel.

Arnold has been working with Unix systems since 1980, when he was introduced to a PDP-11 running a version of Sixth Edition Unix. His experience also includes multiple commercial Unix systems, from Sun, IBM, HP and DEC. He has been working with GNU/Linux systems since 1996.

Arnold has also been a heavy awk user since 1987, when he became involved with gawk, the GNU project’s version of awk. As a member of the POSIX 1003.2 balloting group, he helped shape the POSIX standard for awk. He is the long-time maintainer of gawk and its documentation.

In previous incarnations he has been a systems administrator, and a teacher of Unix and networking Continuing Education classes. He has also had more than one poor experience with start-up software companies, which he prefers not to think about anymore.

In Israel, he worked for several years writing high end Command and Control related software at a leading Israeli software company. He then spent a long time working as a software engineer at Intel and later at McAfee. These days he works at a smaller company, which provides network security monitoring for the manufacturing and building management industries. His personal web site may be found at http://www.skeeve.com.

O’Reilly has been keeping him busy: He is the author and/or coauthor of the bestselling titles: Unix In A Nutshell, Effective awk Programming, sed & awk, Classic Shell Scripting, and several pocket references.

Elbert Hannah started out as a professional musician, changed direction and chose computers and IT for his career. While vi, and later Vim, may not be the sole reason for the switch, one cannot discount the contribution “finding” vi made to his change in career choice.

Elbert finds particular joy knowing he writes and creates this book on Vim using Vim!

Starting as a music major in college, playing cello for a living, a life-changing bicycling accident changed his path forever. With no use of one hand, unable to play cello, Elbert temporarily chose mathematics as his major while healing. Mathematics required Computer Science as a minor and that was that. Elbert maintained his love for music and continues to play non-professionally today, but IT became his career.

Elbert discovered Unix while working in the Telco industry, finding a Job Entry (RJE) linked to the IBM mainframe. He discovered that many processes were easier when diverted to the AT&T System V Unix computer by leveraging the myriad “specialized” (do one thing and do it well) commands for transformations and reports, and then diverted back to the mainframe.

His early work with Unix required deep understanding of ed and that set the stage for his long journey learning, loving, and evangalizing vi and eventually Vim. The seventh and eighth editions of Learning the vi and Vim Editors are Elbert’s way of paying forward his appreciation and respect for Vim’s impact in the coding universe.

Elbert specialized in integration of disparate systems. There are many users who use his applications, not aware that underneath are many separate applications. If you dig deep enough, you might find his picture on the cover of CEO Magazine (circa early to mid ’90s) for his work integrating Telco Facilities and allocation applications.

Elbert developed an external web tool providing quick and easy, and enhanced ways to find information from a third party’s product which quickly established itself as a popular troubleshooting method for support teams and devops staff. He gave a presentation demonstrating the web tool in Las Vegas, 2018.

Colophon

The animal on the cover of Learning the vi and Vim Editors, Eighth Edition, is a tarsier, a nocturnal mammal related to the lemur. Its generic name, Tarsius, is derived from the animal’s very long ankle bone, the tarsus. The tarsier is a native of the East Indies jungles from Sumatra to the Philippines and Sulawesi, where it lives in the trees, leaping from branch to branch with extreme agility and speed.

A small animal, the tarsier’s body is only 6 inches long, followed by a 10-inch tufted tail. It is covered in soft, brown or gray silky fur, and has a round face and huge eyes. Its arms and legs are long and slender, as are its digits, which are tipped with rounded, fleshy pads to improve its grip on trees. Tarsiers are active only at night, hiding during the day in tangles of vines or in the tops of tall trees. They subsist mainly on insects and, though very curious animals, tend to be loners.

The cover image is a 19th-century engraving from the Dover Pictorial Archive. The cover font is Adobe’s ITC Garamond. The text font is Linotype Birka, the heading font is Adobe Myriad Condensed, and the code font is LucasFont’s TheSansMonoCondensed.

1. 1. The vi Text Editor

1. A Brief Historical Perspective

2. Opening and Closing Files

1. Opening a File

2. Problems Opening Files

3. Modus Operandi

4. Saving and Quitting a File

3. Quitting Without Saving Edits

1. Problems Saving Files

2. Exercises

2. 2. Simple Editing

1. vi Commands

2. Moving the Cursor

1. Single Movements

2. Numeric Arguments

3. Movement Within a Line

4. Movement by Text Blocks

3. Simple Edits

1. Inserting New Text

2. Appending Text

3. Changing Text

4. Changing Case

5. Deleting Text

6. Moving Text

7. Copying Text

8. Repeating or Undoing Your Last Command

4. More Ways to Insert Text

1. Numeric Arguments for Insert Commands

5. Joining Two Lines with J

1. Problems with vi Commands

6. Mode Indicators

7. Review of Basic vi Commands