## 5.5. Editing Multiple Files

ex commands enable you to switch between multiple files. The advantage to editing multiple files is speed. If you are sharing the system with other users, it takes time to exit and reenter vi for each file you want to edit. Staying in the same editing session and traveling between files is not only faster for access, but you also save abbreviations and command sequences that you have defined (see Chapter 7), and you keep yank buffers so that you can copy text from one file to another.

### 5.5.1. Invoking vi on Multiple Files

When you first invoke vi, you can name more than one file to edit, and then use ex commands to travel between the files. For example:

>     $ vi file1 file2

edits file1 first. After you have finished editing the first file, the ex command `:w` writes (saves) file1 and `:n` calls in the next file (file2).

Suppose you want to edit two files, practice and note.

Keystrokes | Results
--- | ---
`vi practice note` | Open the two files practice and note. The first-named file, practice, appears on your screen. Perform any edits.
`:w` | Save the edited file practice with the ex command `w`. Press RETURN.
`:n` | Call in the next file, note, with the ex command `n`. Press RETURN. Perform any edits.
`:x` | Save the second file, note, and quit the editing session.

### 5.5.2. Using the Argument List

ex actually lets you do more than just move to the next file in the argument list with `:n`. The `:args` command (abbreviated `:ar`) lists the files named on the command line, with the current file enclosed in brackets.

Keystrokes | Results
--- | ---
`vi practice note` | Open the two files practice and note. The first-named file, practice, appears on your screen.
`:args` | vi displays the argument list in the status line, with brackets around the current filename.

The `:rewind` (`:rew`) command resets the current file to be the first file named on the command line. elvis and vim provide a corresponding `:last` command to move to the last file on the command line.

### 5.5.3. Calling in New Files

You don't have to call in multiple files at the beginning of your editing session. You can switch to another file at any time with the ex command `:e`. If you want to edit another file within vi, you first need to save your current file (`:w`), then give the command:

>     :e filename

Suppose you are editing the file practice and want to edit the file letter, then return to practice.

Keystrokes | Results
--- | ---
`:w` | Save practice with `w` and press RETURN. practice is saved and remains on the screen. You can now switch to another file, because your edits are saved.
`:e letter` | Call in the file letter with `e` and press RETURN. Perform any edits.

vi "remembers" two filenames at a time as the current and alternate filenames. These can be referred to by the symbols `%` (current filename) and `#` (alternate filename). `#` is particularly useful with `:e`, since it allows you to switch easily back and forth between two files. In the example given just above, you could return to the first file, practice, by typing the command `:e #`. You could also read the file practice into the current file by typing `:r #`.

If you have not first saved the current file, vi will not allow you to switch files with `:e` or `:n` unless you tell it imperatively to do so by adding an exclamation point after the command.

For example, if after making some edits to letter, you wanted to discard the edits and return to practice, you could type `:e! #`.

The following command is also useful. It discards your edits and returns to the last saved version of the current file:

>     :e!

In contrast to the `#` symbol, `%` is useful mainly when writing out the contents of the current buffer to a new file. For example, a few pages earlier, in the section "Renaming the Buffer," we showed how to save a second version of the file practice with the command:

>     :w practice.new

Since `%` stands for the current filename, that line could also have been typed:

>     :w %.new

### 5.5.4. Switching Files from vi

Since switching back to the previous file is something that tends to happen a lot, you don't have to move to the ex command line to do it. The vi command `^^` (the "control" key with the caret key) will do this for you. Using this command is the same as typing `:e #`. As with the `:e` command, if the current buffer has not been saved, vi will not let you switch back to the previous file.

### 5.5.5. Edits Between Files

When you give a yank buffer a one-letter name, you have a convenient way to move text from one file to another. Named buffers are not cleared when a new file is loaded into the vi buffer with the `:e` command. Thus, by yanking or deleting text from one file (into multiple named buffers if necessary), calling in a new file with `:e`, and putting the named buffer(s) into the new file, you can transfer material between files.

The following example illustrates how to transfer text from one file to another.

Keystrokes | Results
--- | ---
`"f4yy` | Yank four lines into buffer `f`.
`:w` | Save the file.
`:e letter` | Enter the file letter with `:e`. Move the cursor to where the copied text will be placed.
`"fp` | Place yanked text from named buffer `f` below the cursor.

Another way to move text from one file to another is to use the ex commands `:ya` (yank) and `:pu` (put). These commands work the same way as the equivalent vi commands `y` and `p`, but they are used with ex's line-addressing capability and named buffers.

For example:

>     :160,224ya  a

would yank (copy) lines 160 through 224 into buffer `a`. Next you would move with `:e` to the file where you want to put these lines. Place the cursor on the line where you want to put the yanked lines. Then type:

>     :pu a

to put the contents of buffer `a` after the current line.

Copyright © 2003 O'Reilly & Associates. All rights reserved.