An editing task is hardly ever unstructured. A change often needs to be made several times. In this chapter a number of useful ways to repeat a change will be explained.
- Repeating with Visual mode
- Add and subtract
- Making a change in many files
- Using Vim from a shell script
Table of contents
26.1Repeating with Visual mode
Visual mode is very handy for making a change in any sequence of lines. You can see the highlighted text, thus you can check if the correct lines are changed. But making the selection takes some typing. The
gv command selects the same area again. This allows you to do another operation on the same text.
Suppose you have some lines where you want to change
The financial results for 2001 are better than for 2000. The income increased by 50%, even though 2001 had more rain than 2000. 2000 2001 income 45,403 66,234
2002. Select the lines in Visual mode, and use:
gv to reselect the same text. It doesn't matter where the cursor is. Then use
:s/2000/2001/g to make the second change.
Obviously, you can repeat these changes several times.
26.2Add and subtract
When repeating the change of one number into another, you often have a fixed offset. In the example above, one was added to each year. Instead of typing a substitute command for each year that appears, the CTRL‑A command can be used.
Using the same text as above, search for a year:
Now press CTRL‑A. The year will be increased by one:
The financial results for 2002 are better than for 2000. The income increased by 50%, even though 2001 had more rain than 2000. 2000 2001 income 45,403 66,234
n to find the next year, and press
. to repeat the
CTRL‑A ( is a bit quicker to type). Repeat
. for all years that appear.
Hint: set the hlsearch option to see the matches you are going to change, then you can look ahead and do it faster.
Adding more than one can be done by prepending the number to CTRL‑A. Suppose you have this list:
1. item four 2. item five 3. item six
Move the cursor to
1. and type:
1. will change to
4.. Again, you can use
. to repeat this on the other numbers.
Using CTRL‑A on these numbers results in:
7 plus one is 10? What happened here is that Vim recognized
007 as an octal number, because there is a leading zero. This notation is often used in C programs. If you do not want a number with leading zeros to be handled as octal, use this:
The CTRL‑X command does subtraction in a similar way.
26.3Making a change in many files
Suppose you have a variable called
x_cnt and you want to change it to
x_counter. This variable is used in several of your C files. You need to change it in all files. This is how you do it.
Put all the relevant files in the argument list:
This finds all C files and edits the first one. Now you can perform a substitution command on all these files:
:argdo %s/\<x_cnt\>/x_counter/ge | update
:argdo command takes an argument that is another command. That command will be executed on all files in the argument list.
%s substitute command that follows works on all lines. It finds the word
\> are used to match the whole word only, and not
The flags for the substitute command include
g to replace all occurrences of
x_cnt in the same line. The
e flag is used to avoid an error message when
x_cnt does not appear in the file. Otherwise
:argdo would abort on the first file where
x_cnt was not found.
| separates two commands. The following
update command writes the file only if it was changed. If no
x_cnt was changed to
x_counter nothing happens.
There is also the
:windo command, which executes its argument in all windows. And
:bufdo executes its argument on all buffers. Be careful with this, because you might have more files in the buffer list than you think. Check this with the
:buffers command (or
26.4Using Vim from a shell script
Suppose you have a lot of files in which you need to change the string
Jones and then print it. How do you do that? One way is to do a lot of typing. The other is to write a shell script to do the work.
The Vim editor does a superb job as a screen-oriented editor when using Normal mode commands. For batch processing, however, Normal mode commands do not result in clear, commented command files; so here you will use Ex mode instead. This mode gives you a nice command-line interface that makes it easy to put into a batch file. ("Ex command" is just another name for a command-line (
The Ex mode commands you need are as follows:
%s/-person-/Jones/g write tempfile quit
You put these commands in the file
change.vim. Now to run the editor in batch mode, use this shell script:
for file in *.txt; do vim -e -s $file < change.vim lpr -r tempfile done
The for-done loop is a shell construct to repeat the two lines in between, while the
$file variable is set to a different file name each time.
The second line runs the Vim editor in Ex mode (-e argument) on the file
$file and reads commands from the file
change.vim. The -s argument tells Vim to operate in silent mode. In other words, do not keep outputting the :prompt, or any other prompt for that matter.
The "lpr -r tempfile" command prints the resulting
tempfile and deletes it (that's what the -r argument does).
#Reading from stdin
Vim can read text on standard input. Since the normal way is to read commands there, you must tell Vim to read text instead. This is done by passing the
- argument in place of a file. Example:
ls | vim -
This allows you to edit the output of the
ls command, without first saving the text in a file.
If you use the standard input to read text from, you can use the
-S argument to read a script:
producer | vim -S change.vim -
#Normal mode scripts
If you really want to use Normal mode commands in a script, you can use it like this:
vim -s script file.txt ...
-s has a different meaning when it is used without
-e. Here it means to source the
script as Normal mode commands. When used with
-e it means to be silent, and doesn't use the next argument as a file name.
The commands in
script are executed like you typed them. Don't forget that a line break is interpreted as pressing <Enter>. In Normal mode that moves the cursor to the next line.
To create the script you can edit the script file and type the commands. You need to imagine what the result would be, which can be a bit difficult. Another way is to record the commands while you perform them manually. This is how you do that:
vim -w script file.txt ...
All typed keys will be written to
script. If you make a small mistake you can just continue and remember to edit the script later.
-w argument appends to an existing script. That is good when you want to record the script bit by bit. If you want to start from scratch and start all over, use the
-W argument. It overwrites any existing file.