If you want to call Vim to edit more than one file, you can add an option to the command line to open all of the buffers in split windows on startup:
-O — Open all buffers in vertically split windows, like :vsp-o — Open all buffers in horizontally split windows, like :sp
The same can also be done for tabs:
-p — Open all buffers in tabs, like :tabnew
The command line in Vim for ex commands can be edited with a few of the GNU Readline key combinations that may be familiar to Bash or Emacs users, so it’s reasonably easy to edit it, for example to type in complex search patterns and replacements.
However, if you want the full facility of Vim editing for your commands, it can be helpful to use Vim’s command line window, which will allow you to enter commands and edit previous ones with the usual normal and insert mode.
You can open the command line window from normal mode in one of four ways:
q: — Open with a command history from normal modeq/ — Open with a search history from normal mode (to search forward)q? — Open with a search history from normal mode (to search backward)Ctrl+F — Open with a command history from command modeNote that this doesn’t work while you’re recording macros, since pressing q stops the recording.
The window is always immediately above the status bar, and its height can be
set via the cmdwinheight option.
Once the command line window is opened with q:, you can browse through it and
press Enter on any line to issue the same command again. You can also edit it
beforehand, perhaps to fix a mistyped command. The window will close when this
is done, but you can close it with Ctrl+W, C the same as any other window if
you change your mind.
Vim command line window
Note that you can’t move to another window while this one is open, nor can you load another buffer into it.
Similar to the above, if you open the command window with q/ or q?, it
shows a history of your searches, and pressing enter on any line will issue the
same again, in the appropriate direction.
Vim search window
For more information on how the command window works, check out :help
command-line-window.
One of my favourite technical presentations I’ve read online has been Hal Pomeranz’s Unix Command-Line Kung Fu, a catalogue of shortcuts and efficient methods of doing very clever things with the Bash shell. None of these are grand arcane secrets, but they’re things that are often forgotten in the course of daily admin work, when you find yourself typing something you needn’t, or pressing up repeatedly to find something you wrote for which you could simply search your command history.
I highly recommend reading the whole thing, as I think even the most experienced shell users will find there are useful tidbits in there that would make their lives easier and their time with the shell more productive, beyond simpler things like tab completion. Here, I’ll recap two of the things I thought were the most simple and useful items in the presentation for general shell usage, and see if I can add a little value to them with reference to the Bash manual.
For many shell users, finding a command in history means either pressing the up
arrow key repeatedly, or perhaps piping a history call through grep. It
turns out there’s a much nicer way to do this, using Bash’s built-in history
searching functionality; if you press Ctrl+R and start typing a search pattern,
the most recent command matching that pattern will automatically be inserted on
your current line, at which point you can adapt it as you need, or simply press
Enter to run it again. You can keep pressing Ctrl+R to move further back in
your history to the next-most recent match. On my shell, if I search through my
history for git, I can pull up what I typed for a previous commit:
(reverse-i-search)`git': git commit -am "Pulled up-to-date colors."
This functionality isn’t actually exclusive to Bash; you can establish a history search function in quite a few tools that use GNU Readline, including the MySQL client command line.
You can search forward through history in the same way with Ctrl+S, but it’s likely you’ll have to fix up a couple of terminal annoyances first.
Additionally, if like me you’re a Vim user and you don’t really like having to reach for the arrow keys, or if you’re on a terminal where those keys are broken for whatever reason, you can browse back and forth within your command history with Ctrl+P (previous) and Ctrl+N (next). These are just a few of the Emacs-style shortcuts that GNU Readline provides; check here for a more complete list.
The last command you ran in Bash can be abbreviated on the next line with two exclamation marks:
$ echo "Testing."
Testing.
$ !!
Testing.
You can use this to simply repeat a command over and over again, although for
that you really should be using watch, but more interestingly it turns
out this is very handy for building complex pipes in stages. Suppose you were
building a pipeline to digest some data generated from a program like
netstat, perhaps to determine the top 10 IP addresses that are holding open
the most connections to a server. You might be able to build a pipeline like
this:
# netstat -ant
# !! | awk '{print $5}'
# !! | sort
# !! | uniq -c
# !! | sort -rn
# !! | sed 10q
Similarly, you can repeat the last argument from the previous command line
using !$, which is useful if you’re doing a set of operations on one file,
such as checking it out via RCS, editing it, and checking it back in:
$ co -l file.txt
$ vim !$
$ ci -u !$
Or if you happen to want to work on a set of arguments, you can repeat all of
the arguments from the previous command using !*:
$ touch a.txt b.txt c.txt
$ rm !*
When you remember to user these three together, they can save you a lot of
typing, and will really increase your accuracy because you won’t be at risk of
mistyping any of the commands or arguments. Naturally, however, it pays to be
careful what you’re running through rm!