Archives
Categories
SubscribeWorking With History in Bash
Yesterday we talked about favorite bash features (on the ##textmate IRC channel). I figured it was worth posting mine to this blog, they mostly revolve around history, hence the title.
Setup
My shell history collects a lot of complex command invocations which take time to figure out. To ensure that I have access to them at a later time, I have the following 3 lines in my bash init:
export HISTCONTROL=erasedups
export HISTSIZE=10000
shopt -s histappend
The first one will remove duplicates from the history (when a new item is added). For example if you switch between running make and ./a.out in a shell, you may later find that the last 100 or so history items is a mix of these two commands. Not very useful.
The second one increase the history size. With duplicates erased, the history already holds a lot more actual information, but I still like to increase the default size of only 1,000 items.
The third line ensures that when you exit a shell, the history from that session is appended to ~/.bash_history. Without this, you might very well lose the history of entire sessions (rather weird that this is not enabled by default).
History Searching
Now that I have my history preserved nicely in ~/.bash_history there are a few ways to search it.
Using Grep
The most crude is grep. You can do:
history|grep iptables
For me (on this particular Linux server) I get:
4599 iptables -N http-block
4600 iptables -A http-block -s 58.60.43.196 -j DROP
4601 iptables -A INPUT -p tcp --dport 80 -j http-block
4602 iptables -L http-block
4603 iptables-save -c
4604 history|grep iptables
I do this often enough to have an alias for history (which is just h).
From the output I can either copy/paste the stuff I want, or repeat a given history event. You’ll notice that each history event has a number, you can repeat e.g. event number 4603 simply by running:
!4603
I will write a bit more about referencing history events in History Expansion.
Prefix Searching
Similar to how you can press arrow up for the previous history event, there is a function you can invoke for the previous history event with the same prefix as what is to the left of the insertion point.
This function is called history-search-backward and by default does not have a key equivalent. So to actually reach this function, I have the following in ~/.inputrc (or /etc/inputrc when I control the full system):
"\ep": history-search-backward
This places the function on ⎋P (escape P). So if I want to repeat the iptables-save -c history event we found in previous section, all I do is type ipt and hit ⎋P. If it finds a later event with the same prefix, hit ⎋P again to go further back.
This functionality is offered by the readline library, so if you setup this key, you have access to prefix searching in all commands which use this library.
Incremental Search
It is possible to press ⌃R to do an incremental (interactive) search of the history.
Personally I am not a big fan of this feature, so I will leave it at that :)
Update: The reason I dislike ⌃R is both because the interactive stuff just seems to get in the way (when ⎋P is what I need 99% of the time) and because it fails in cases where I “switch shell”, for example I may do: ssh mm press return, then instantly type: f⎋P and again hit return (to execute free -m on the server called mm). I enter this before the connection to the server has been fully established, and here ⌃R would have been taken by the local shell, but it is the shell history at the server I want to search.
History Expansion
History Expansion was what we did above when we ran !4603. It is a DSL for referencing history events and optionally run transformations on these.
Anyone interested in this should run man bash and search for History Expansion, but just to give you a feel for what it is, I will reference a subset of the manual and provide a few examples.
Event Designators
First, an event designator starts with ! and then the event we want to reference. This can be:
«n» Reference event number «n».
-«n» Go «n» events back.
! Last line (this is the default).
# Current line.
«text» Last event starting with «text».
?«text» Last event containing «text».
So if we want to re-run our iptables-save -c we can do: !ipt.
What’s more useful though is to use history references as part of larger commands.
For example take this example:
% which ruby
/usr/bin/ruby
% ls -l $(!!)
lrwxr-xr-x 1 root wheel 76 30 Oct 2007 /usr/bin/ruby -> ../../System/Library/Frameworks/Ruby.framework/Versions/Current/usr/bin/ruby
Or something like:
% make some_target
(no errors)
% path/to/target some arguments
(no errors)
% !-2 && !-1
Word Designators
In the previous section we referenced entire history events. It is possible to reference just a subset of a history event by appending a : to the event designator and then the word of interest, the two most useful are:
«n» Reference the «n»’th word.
$ Reference the last word.
So for example we can do:
% mkdir -p /path/to/our/www-files
(no errors)
% chown www:www !$
(no errors)
Here we reference last word of last line. We can also reference stuff on the same line, e.g.:
% cp /path/to/important/file !#:1_backup
To reference the last word of last line one can also press ⎋_ which will immediately insert that word.
Modifiers
To make history substitution even more useful (and harder to remember), one can also add a modifier to the event designator.
The most useful modifiers are in my experience :h and :t, these are head and tail respectively or better know as dirname and basename.
An example could be:
% ls -l /path/to/some/file
(listing of file)
% cd !$:h
(change directory to that of file)
Brace Expansion
Somewhat related to the backup example where we reference the first argument as !#:1 and append _backup to this, another approach is bracket expansion.
Anywhere on a command line, one can write {a,b,c} which will expand to the 3 words a, b, and c. If we include a prefix/suffix, that will be part of each of the expanded words. We can also leave the word in the braces empty, and have it expand to just the prefix/suffix, so for example we can do:
% cp /path/to/important/file{,_backup}
This is functionally equivalent to:
% cp /path/to/important/file !#:1_backup
But lack of hardcoded word number is IMO an improvement.
