11.7 History Substitutions

[Although most of the examples here use echo to demonstrate clearly just what is going on, you'll normally use history with other UNIX commands. -JP]

The exclamation point (!) is the C shell's default (11.15) history substitution character. (It's used in bash, too.) This allows you to recall previously entered commands and re-execute them without retyping. The number of commands saved is up to you. To set this number, put a line in your shell setup file (2.2) like this:

set history=40   ...C shell

HISTSIZE=40   ...bash, ksh

This means that the C shell will save the last 40 commands. To list out these 40 commands use:

% history

To see just the last ten commands in csh or bash, use history 10. In the C shell, you can also list out the commands in reverse with history -r.

To use the ! in a command line, you have several choices. Some of the following examples are more of a headache than they may be worth. But they are used mostly to select arguments from the command line in aliases (10.3). Here they are:

• !! repeats the last command.

• !: repeats the last command. This form is used if you want to add a modifier (9.6) like:

  % echo xy
  xy
  % !:s/xy/yx
  echo yx
  yx

  The second ! was left out.

• !so repeats the last command that starts with so.

• !?fn? repeats the last command that has fn anywhere in it. The string could be found in an argument or in the command name. This is opposed to !fn, in which !fn must be in a command name. (The last ? need not be there. Thus !?fn means the same thing.)

• !34 executes command number 34. You can find the appropriate history number when you list your history using the history command, or by putting the history number in your prompt . (7.2)

• !! & adds an ampersand (&) to the end of the last command, which executes it and places it into the background. You can add anything to the end of a previous command. For example:

  % cat -v foo
         ...
  % !! | more
  cat -v foo | more
         ...

  In this case the shell will repeat the command to be executed and run it, adding the pipe through the more (25.3) pager. Another common usage is:

  % cat -v foo
         ...
  % !! > out
  cat -v foo > out

  which returns the command but redirects the output into a file.

• !:0 selects only the command name; rather than the entire command line.

  % /usr/bin/grep Ah fn1
         ...
  % !:0 Bh fn2
  /usr/bin/grep Bh fn2

  Note that as an operator (9.6) :0 can be appended to these history substitutions as well. For example, !!:0 will give the last command name, and a colon followed by any number will give the corresponding argument. For example:

  % cat fn fn1 fn2
         ...
  % more !:3
  more fn2
         ...

  gives the third argument.

• !:2-4 gives the second through the fourth argument, or any numbers you choose:

  % echo 1 2 3 4 5
  1 2 3 4 5
  % echo !:2-4
  echo 2 3 4
  2 3 4

• !:-3 gives zero through the third argument, or any number you wish:

  % echo 1 2 3 4
  1 2 3 4
  % echo !:-3
  echo echo 1 2 3
  echo 1 2 3

• !^ gives the first argument of the previous command. This is the same as !:1. Remember that, just as the ^ (caret) is the beginning-of-line anchor in regular expressions (26.4), !^ gives the beginning history argument.

  % cat fn fn1 fn2
         ...
  % more !^
  more fn
         ...

• !$ gives the last argument of the last command. In the same way that $ (dollar sign) is the end-of-line anchor in regular expressions, !$ gives the ending history argument. Thus:

  % cat fn
         ...
  % more !$
  more fn
         ...

  The new command (more) is given the last argument of the previous command.

• !* is shorthand for the first through the last argument. This is used a lot in aliases:

  % echo 1 2 3 4 5
  1 2 3 4 5
  % echo !*
  echo 1 2 3 4 5
  1 2 3 4 5

  In an alias:

  alias vcat 'cat -v \!* | more'

  will pipe the output of cat -v (25.7) command through more. The backslash (\) has to be there to hide the history character, !, until the alias is used-see article 10.3 for more information.

• !:2* gives the second through the last arguments:

  % echo 1 2 3 4 5
  1 2 3 4 5
  % echo !:2*
  echo 2 3 4 5
  2 3 4 5

• !:2- like 2* but the last argument is dropped:

  % echo 1 2 3 4 5
  1 2 3 4 5
  % echo !:2-
  echo 2 3 4
  2 3 4

• !?fn?% gives the first word found that has fn in it:

  % sort fn1 fn2 fn3
         ...
  % echo !?fn?%
  echo fn1
  fn1

  That found the fn in fn1. You can get wilder with:

  % echo 1 2 3 4 5
  1 2 3 4 5
  % echo !?ec?^
  echo 1
  1

  That selected the command that had ec in it, and the caret (^) said to give the first argument of that command. You can also do something like:

  % echo fn fn1 fn2
  fn fn1 fn2
  
  % echo !?fn1?^ !$
  echo fn fn2
  fn fn2

  That cryptic command told the shell to look for a command that had fn1 in it (!?fn1?), and gave the first argument of that command (^). Then it gave the last argument (!$).

• ^xy^yx is the shorthand substitution (11.3, 11.5) command. In the case of:

  % echo xxyyzzxx
  xxyyzzxx
  % ^xx^ab
  echo abyyzzxx
  abyyzzxx

  it replaced the characters xx with ab. This makes editing the previous command much easier.

• !!:s/xx/ab/ is doing the same thing as the previous example, but it is using the substitute command instead of the ^. This works for any previous command, as in:

  % more afile bfile
         ...
  % echo xy
  xy
  % !m:s/b/c/
  more afile cfile

  You do not have to use the slashes (/); any character can act as a delimiter.

  % !!:s:xy:yx

  There we used the colons (:) [good when the word you're trying to edit contains a slash-JP ]. If you want to add more to the replacement, use & to "replay it" and then add on whatever you like:

  % echo xy
  xy
  % !!:s/xy/&yx
  echo xyyx
  xyyx

  The & in the replacement part said to give what the search part found, which was the xy characters.

  The search part, or left side, cannot include metacharacters (26.3). You must type the actual string you are looking for.

  Also, the example above only replaces the first occurrence of xy. To replace them all, use g:

  % echo xy xy xy xy
  xy xy xy xy
  % !!:s/xy/yx/
  echo yx xy xy xy
  yx xy xy xy
  % !!:gs/xy/yx/
  echo yx yx yx yx
  yx yx yx yx

  The g command in this case meant do all the xys. And oddly enough, the g has to come before the s command.

  Or you could have done:

  % echo xy xy xy xy
  xy xy xy xy
  % !!:s/xy/yx/
  echo yx xy xy xy
  yx xy xy xy
  % !!:g&
  echo yx yx yx yx
  yx yx yx yx

  In that case, we told the shell to globally (:g) replace every matched string from the last command with the last substitution (&). Without the g command, the shells would have replaced just one more xy with yx.

  [A "global" substitution works just once per word:

  % echo xyzzy
  xyzzy
  % !!:gs/y/p/
  echo xpzzy
  xpzzy

  The substitution above changed only the first y. -TC ]