5. Text Editors

As a developer, you will edit text files on a regular basis. This can sometimes pose a challenge because Linux offers a variety of editors. In many cases, you should be able to pick your editor, but sometimes you might be forced to use one of the standard editors, such as the vi editor.

This chapter focuses on the editors that are available on Linux distributions. The primary focus is on the vi (or vim) editor because it has the advantage of always being available on whatever Linux distribution you are working on. I introduce some additional editors to help you determine which tool will work best for your situation.

Instead, the developer would use a simple command-based editor, such as the ed editor. With this editor a developer could perform operations such as list the contents of a file (print the file), modify specific characters of a file, or save the contents of a file. However, he accomplished all this in a way that might seem foreign today. The developer wouldn’t see what he was editing, but rather just assume the commands were successful (or print the file to verify).¹

When monitors became more commonplace, the ed editor seemed like a clumsy way to edit a text file. In the mid-1970s a replacement editor named vi (short for visual) was introduced to Unix.² It was a great improvement over the ed editor³ because you could actually see and move around in your document.

vi requires no GUI: Many of the editing tools that this chapter introduces require a graphical user interface. Normally that is not a problem, but on many servers, the GUI isn’t even installed because it tends to be a resource (CPU, memory, and hard drive space) hog. If you might be called upon to edit code on a server, then you might need to know a command-line editor like the vi editor.

vi is a very stable standard: You could take a cryogenically frozen developer from the 1970s who used the vi editor, unfreeze him today and he could edit files using a modern vi editor. Certainly, features have been added to the vi editor since the 1970s, but the core functionality of vi does not change, making it very easy for you to use throughout your career without having to “relearn” how newer versions work.

vi is always there: In every Linux distribution (and all Unix ones as well) the vi editor is there. After you know how to edit files with the vi editor, you can edit files on any Linux machine.⁴

Speed of use: Although you might not believe this initially, you can actually edit files quickly using the vi editor. Granted, this will take many years of practice, but because you never need to use the mouse, you never need to take your hands off your keyboard when editing a file. The commands are also very short, so you can edit files very quickly.

Your distribution might only have the vi editor. Many distributions have both the vi and vim editor. On some distributions, the command vi is actually a link to the vim editor.

An easy way to tell whether you are using the vi or vim editor is to try executing the vi command. If you are using vim, a message like the following appears: VIM – Vi IMproved. If you don’t get this message, then you are using a standard vi editor.⁶

It helps to have a large file to edit. All Linux distributions should come with a /etc/services file that is typically thousands of lines long. You can start by first copying this file to your home directory and then edit the copy with the vi command:

[student@fedora ~]$ cp /etc/services.
[student@fedora ~]$ vi services

While in the command mode, you can’t insert new text into your document because all the keyboard keys are assigned to command tasks. To insert new text, you must use the s command to move from command mode to insert mode. These commands include the following:

i—New text will appear before the cursor position.

a—New text will appear after the cursor position.

I—New text will appear at the beginning of the line.

A—New text will appear at the end of the line.

o—Opens a new line below the line that contains the cursor; new text will be placed on this line.

O—Opens a new line above the line that contains the cursor; new text will be placed on this line.

See Figure 5.1 for a visual description of how these vi commands work.

Note that when you are using the vim editor and enter the insert mode, the bottom part of the screen changes to indicate this. See the -- INSERT -- at the bottom of Figure 5.2.

If you are working in a standard vi editor, then -- INSERT -- does not appear at the bottom of the screen by default. To enable this feature in a standard vi editor, type the following command while in command mode:

:set showmode

When you want to return to command mode, just press the escape (Esc) key. This is normally denoted in documentation as <ESC>. If you return to the command mode, then the -- INSERT -- should disappear from the bottom of the screen.

Many additional movement commands are available, including the following:

$ Move to the last column (character) on the current line

0 Move to the first column (character) on the current line

w Move to the beginning of the next word or punctuation mark

W Move to past the next space

b Move to the beginning of the previous word’s punctuation mark

B Move to the beginning of the previous word, ignoring punctuation

e Move to the end of next word or punctuation mark

E Move to the end of next word, ignoring punctuation

) Move forward one sentence

( Move back one sentence

} Move forward one paragraph

{ Move back one paragraph

H Move to the top of the screen

M Move to the middle of the screen

L Move to the bottom of the screen

[[ Move to the beginning of the document

]] Move to the end of the document

G Move to the end of the document (same as ]])

xG Move to line x (you can also use :x)

Note that these are just some of the movement commands. Here’s a suggestion: spend some time trying out these movement commands and then create a cheat sheet of the commands that you feel will be most useful to you. Make this a cheat sheet that you can add more commands to as you learn additional useful commands.⁸

Placing a number before a command acts as a modifier. You can use modifiers on many different command-mode commands; for example:

3w Move forward three words

5i Insert something five times⁹

4( Move back three paragraphs

You can also use repeat modifiers on commands like deleting, copying, and pasting. Typically, if there is a command-mode command that you would logically want to execute multiple times, then repeat modifiers should work with that command.

If you are using the vim editor, you can undo several actions. Just keep pressing the u character to undo older modifications. You can perform a redo that undoes the changes performed by the undo command by using the ^r (Ctrl+r) command.

Suppose you made a large number of changes since you opened the document and you want to discard them all. In this case, you probably want to close the document without saving and open it again. To close the document without saving changes, type the command :q!. You can find more on this command and other ways to quit the vi editor in the “Saving and Quitting” section later in this chapter.

yw—Copy word. This actually copies from the current character in a word until the end of the word (including punctuation) and the white space after the word. So, if your cursor was on the h in “this is fun,” the cw command would copy “his ” into memory.

yy—Copy current line.

y$—Copy from current character to end of the line.

yG—Copy current line to the end of the document.

You might be wondering “Why use the y character?” This is because the process of copying text into the memory buffer used to be called yanking.

The following is a summary of commonly used deleting commands. Keep in mind, you should execute these while in command mode:¹¹

dw—Delete word; this command actually deletes from the current character in the word until the end of the word (including punctuation) and the white space after the word. So, if your cursor was on the h in “this is fun” the dw command would delete “his ”, resulting in “tis fun.”

dd—Delete current line.

d$—Delete from current character to end of the line.

dG—Delete current line to the end of the document.¹²

x—Delete the character the cursor is currently on (like a delete key).¹³

X—Delete the character before the character the cursor is currently on (like a backspace key).

Pasting commands can be a bit trickier because how they work depends on what you are pasting. For example, suppose you had copied a word into the buffer. In this case, the following describes how the paste commands would work:

p—Pastes the buffer contents before the cursor

P—Pastes the buffer contents after the cursor

The behavior is a bit different if you copy an entire line (or multiple lines) into the buffer:

p—Pastes the buffer contents in the line above the cursor

P—Pastes the buffer contents in the line below the cursor

/ While in command mode, type the / key; this character appears in the bottom-left corner of the terminal window. Now type what you want to search for and then press the Enter key. The vi editor will search forward in the document for the text you asked it to search for.

? While in command mode, type the ? key; this character appears in the bottom-left corner of the terminal window. Now type what you want to search for and then press the Enter key. The vi editor will search backward in the document for the text you asked it to search for.

Suppose your search didn’t find the specific match you were looking for. You can use the n command to find the next match. The n command searches forward when your last search started with the / key and searches backward when your last search started with the ? key.¹⁴

What if you searched for “/one” and realize you will need to press the n key many times to find what you are looking for? After furiously typing n repeatedly, you realize you went past the match that you wanted. To reverse the current search, use the N character (capital N rather than lowercase). When you’re searching forward, N will reverse and search backward in the document. When you’re searching backward, N will reverse and search forward in the document.

:x,ys/pattern/replace/

The values of x and y represent which lines you want to perform the search on. For example, to search and replace on only the first ten lines of the document, use the following syntax:

:1,10s/I/we/

You can use the $ character to represent the last line in the document:

:300,$s/I/we/

So, to perform the substitution on the entire document, use the following:

:1,$s/I/we/

By default, only the first match on each line is replaced. Imagine if the line you are searching for and replacing looked like the following:

The dog ate the dog food from the dog bowl

If the command :s/dog/cat/ were executed on the previous line, then the result would be:

The cat ate the dog food from the dog bowl

To replace all occurrences on a line, add a g¹⁵ at the end of the search command:

:s/dog/cat/g

Searching and replacing is case sensitive. Imagine if the line you are searching and replacing looked like the following:

The Dog ate the dog food from the dog bowl

If the command :s/dog/cat/ were executed on the previous line, then the result would be:

The Dog ate the cat food from the dog bowl

The result matched the second dog because the first one had a capital D character. To perform a case-insensitive search and replace, add an i at the end of the search command:

:s/dog/cat/i

Another operation you can do in this mode is save and quit your document:

:wq

You might also want to just save, but continue working:

:w

You can also save to a different document, but there is a little gotcha to this operation that you will discover. Suppose you want to save changes made to your services file into a file called myservices. Execute the following:

:s myservices

The changes will be placed into this file. However, any further changes will be saved by default into the original services file. Most modern editors “switch” the default save document to whatever the last saved document was, but vi doesn’t do this. To see your current document, type ^G (Ctrl+g).

So, if you want to edit the new file, you should quit the vi editor and open the new file.

If you make changes to a file and then try to quit without saving (:q), you receive an error message like the following:

E37: No write since last change (add ! to override)

To force quit (quit without saving changes), execute the following command:

:q!

The vim editor has some very useful built-in documentation, but you must have a specific software package installed on Red Hat–based distributions¹⁶ in order to be able to access this documentation. Chapter 6 covers installing software in greater detail. For now, just make sure you are logged in as the root user and execute the following command: yum install vim-enhanced

If this package is installed, you can execute the command :help while in the vim editor to see a help document. See Figure 5.4 for an example.

Use your arrow keys (or h, j, k, and l) to scroll through the document. About 20 lines down, you will start to see some subtopics, as shown in Figure 5.5.

Each of these topics, such as quickref and usr_01.txt, are separate help topics. To view them, first exit from the current help document by typing the :q command. Then type a command like the following, replacing topic with the full name of the topic you want to view:

:help topic

For example, to see help on “Using syntax highlighting,” type the following command:

:help usr_06.txt

If you execute the Emacs editor in a command line–only environment, the editor will look like Figure 5.7.

The gedit editor typically is installed on distributions that use the GNOME desktop by default. The kwrite (or KATE) editor typically is installed on distributions that use the KDE desktop by default. However, you can easily install gedit on a system that uses KDE desktop or install kwrite on a GNOME desktop system.

The nano and joe editors provide a simple interface for editing text files. They are command line–only editors, so no GUI is required. See Figure 5.8 for an example of the nano editor.

If you are going to make a career of coding on Linux, you should start to explore these tools (or many of the other similar editing tools). See Figure 5.9 for an example of the bluefish editor.