The Linux command line allows your system to remember commands that you use—up to a limit set by your HISTSIZE variable. Since each user’s HISTSIZE is generally set to 1000, that means Linux can remember the last 1000 commands you entered and make it easy to reuse them without retyping them.
Unless you configure your history settings differently, all of your commands will be remembered. You can put some restrictions on that behavior if you like. For example, you might not want to save every command you use to read a man page or every time you type pwd to ask where you’re currently sitting in the file system. How to restrict the commands that are remembered and which are not is covered here.
The easiest way to reuse a previously entered command is to type “!!” on the command line. This repeats whatever command you last used. Alternatively, you can press the up-arrow key on your keyboard as many times as needed to return to some command in your history buffer that you want to run again or the down-arrow key if you backed up too far. Press the enter key when the command you want to reuse is displayed with your command prompt.
If the command that you want to reuse is one you entered 500 commands earlier, on the other hand, backing up to it in order to avoid retyping it is probably only a good idea if the command is one you really don’t want to type again or you don’t remember.
There is a better approach, though. It involves using the command history | more to start displaying all of the commands in your command history, pressing the enter key until you see the command you want to reuse in the commands listed, and then entering Ctrl+C to stop the history command. Then type ! followed by the number to the left of the command you want to reuse (e.g., !123).
If you know that the command is one you used recently, you can avoid much of the tedium by using a command such as history | tail -20 to view only recently entered commands and find your the one you want to reuse much more quickly.
Here are some additional ways that you can take advantage of what Linux remembers for you.
Reuse a command by typing a portion of it
One easy way to reuse a previously entered command (one that’s still on your command history) is to type the beginning of the command. If the bottom of your history buffers looks like this, you could rerun the ps command that’s used to count system processes simply by typing just !p.
$ history | tail -7 1002 21/02/21 18:24:25 alias 1003 21/02/21 18:25:37 history | more 1004 21/02/21 18:33:45 ps -ef | grep systemd | wc -l 1005 21/02/21 18:33:54 ls 1006 21/02/21 18:34:16 echo “What’s next?”
You can also rerun a command by entering a string that was included anywhere within it. For example, you could rerun the ps command shown in the listing above by typing !?sys? The question marks act as string delimiters.
$ !?sys? ps -ef | grep systemd | wc -l 5
You could rerun the command shown in the listing above by typing !1004 but this would be more trouble if you’re not looking at a listing of recent commands.
Run previous commands with changes
After the ps command shown above, you could count kworker processes instead of systemd processes by typing ^systemd^kworker^. This replaces one process name with the other and runs the altered command. As you can see in the commands below, this string substitution allows you to reuse commands when they differ only a little.
$ ps -ef | grep systemd | awk ‘{ print $2 }’ | wc -l
5
$ ^systemd^smbd^
ps -ef | grep smbd | awk ‘{ print $2 }’ | wc -l
5
$ ^smbd^kworker^
ps -ef | grep kworker | awk ‘{ print $2 }’ | wc -l
13
The string substitution is also useful if you mistype a command or file name.
$ sudo ls -l /var/log/samba/corse ls: cannot access ‘/var/log/samba/corse’: No such file or directory $ ^se^es^ sudo ls -l /var/log/samba/cores total 8 drwx———. 2 root root 4096 Feb 16 10:50 nmbd drwx———. 2 root root 4096 Feb 16 10:50 smbd
Reach back into history
You can also reuse commands with a character string that asks, for example, to rerun the command you entered some number of commands earlier. Entering !-11 would rerun the command you typed 11 commands earlier. In the output below, the !-3 reruns the first of the three earlier commands displayed.
$ ps -ef | wc -l 132 $ who shs pts/0 2021-02-21 18:19 (192.168.0.2) $ date Sun 21 Feb 2021 06:59:09 PM EST $ !-3 ps -ef | wc -l 133
Reuse command arguments
Another thing you can do with your command history is reuse arguments that you provided to various commands. For example, the character sequence !:1 represents the first argument provided to the most recently run command, !:2 the second, !:3 the third and so on. !:? represents the final argument. In this example, the arguments are reversed in the second echo command.
$ echo be the light be the light $ echo !:3 !:2 !:1 echo light the be light the be $ echo !:3 !:$ echo light light light light
If you want to run a series of commands using the same argument, you could do something like this:
$ echo nemo nemo $ id !:1 id nemo uid=1001(nemo) gid=1001(nemo) groups=1001(nemo),16(fish),27(sudo) $ df -k /home/!:$ df -k /home/nemo Filesystem 1K-blocks Used Available Use% Mounted on /dev/sdb1 446885824 83472864 340642736 20% /home
Of course, if the argument was a long and complicated string, it might actually save you some time and trouble to use this technique. Please remember this is just an example!
Wrap-Up
Simple history command tricks can often save you a lot of trouble by allowing you to reuse rather than retype previously entered commands. Remember, however, that using strings to identify commands will recall only the most recent use of that string and that you can only rerun commands in this way if they are being saved in your history buffer.
Copyright © 2021 IDG Communications, Inc.
