History, Ctrl-R and readline editing

You ran a 90-character rsync command ten minutes ago and need it again. Retyping it invites a typo; scrolling up through dozens of lines is slow. Bash keeps a history list of every command, and a few keystrokes bring any of them back exactly.

Here you learn to search and reuse history with Ctrl-R and the history designators !!, !$ and !n, to set how much history is kept and what is left out of it, and to move around a command line with readline, the line editor built into Bash.

Reuse commands with Ctrl-R and history expansion

Press Ctrl-R and type a few letters: Bash searches your history listhistory list: The numbered list of commands Bash keeps for the session and saves to the history file; browse it with the history builtin and search it with Ctrl-R. backwards and shows the most recent command that contains them, which you run with Enter or edit first. For quick reuse without searching, Bash offers history expansionhistory expansion: Shorthand starting with ! (such as !!, !$ and !n) that Bash replaces with a past command or part of one before running the line; interactive shells only., words starting with ! that the shell replaces before running the line. This example feeds a sequence to an interactive Bash and prints what each designator did:

from session import run

# History expansion in an interactive Bash reading a file of commands: !! repeats the last command, ^old^new fixes a
# typo in it, !$ is its last word and !1 re-runs entry 1. The history list stores each command in its expanded form.
run("""
printf '%s\\n' 'echo alpha beta gamma' '^beta^BETA' '!!' 'echo "last arg: !$"' '!1' 'history 6' > demo.bash
bash --norc --noprofile -i demo.bash 2>/dev/null
""")

$ printf '%s\n' 'echo alpha beta gamma' '^beta^BETA' '!!' 'echo "last arg: !$"' '!1' 'history 6' > demo.bash
$ bash --norc --noprofile -i demo.bash 2>/dev/null
alpha beta gamma
alpha BETA gamma
alpha BETA gamma
last arg: gamma
alpha beta gamma
    1  echo alpha beta gamma
    2  echo alpha BETA gamma
    3  echo alpha BETA gamma
    4  echo "last arg: gamma"
    5  echo alpha beta gamma
    6  history 6

echo alpha beta gamma ran first. ^beta^BETA re-ran it with the first beta changed to BETA, printing alpha BETA gamma. !! repeated that whole command, !$ stood for its last word (gamma), so echo "last arg: !$" printed last arg: gamma, and !1 re-ran entry 1 by its number. The history list at the end shows each command stored in its expanded form.

A few designators cover most use: !! the last command (often sudo !!), !$ its last argument, !^ its first, !n entry number n, !-2 two back, and !abc the most recent command starting with abc. History expansion works only in interactive shells, so a script is never surprised by a !.

Outside that one quoting trap, the designators are safe and save a lot of typing once they are habit.

Shape your history: size, duplicates and timestamps

By default the history file can fill with near-duplicates and secrets. A few variables, set in ~/.bashrc, shape what is kept. The most useful is HISTCONTROL=ignoreboth, which drops a command that repeats the one before it and any command that begins with a space:

from session import run

# HISTCONTROL=ignoreboth drops a command that repeats the one before it and a command that starts with a space. Both
# commands still run; they just do not go into the history list. The leading space is the way to keep a secret out.
run("""
printf '%s\\n' 'HISTCONTROL=ignoreboth' 'echo build' 'echo build' ' echo token=secret' 'echo deploy' 'history 5' > ctrl.bash
bash --norc --noprofile -i ctrl.bash 2>/dev/null
""")

$ printf '%s\n' 'HISTCONTROL=ignoreboth' 'echo build' 'echo build' ' echo token=secret' 'echo deploy' 'history 5' > ctrl.bash
$ bash --norc --noprofile -i ctrl.bash 2>/dev/null
build
build
token=secret
deploy
    1  HISTCONTROL=ignoreboth
    2  echo build
    3  echo deploy
    4  history 5

Both echo build lines ran, but the repeat was not stored, so the history list holds echo build once. The space-prefixed echo token=secret ran and printed its output, yet never entered the list: starting a command with a space is the usual way to keep a one-off secret out of history. echo deploy was stored normally.

shopt -s histappend matters when you keep several terminals open: without it, the last one to close overwrites the file with only its own history, losing the rest. With it, each shell appends, so no session’s commands are thrown away.

Edit the line with readline

Everything you type at the prompt is handled by readlinereadline: The line-editing library inside Bash that handles typing at the prompt, key bindings and history search; configured in ~/.inputrc and shared with other programs., the line editor inside Bash. Its default keys come from the Emacs editor, so moving and deleting is fast once the keys are habit:

Prefer vi keys? set -o vi switches readline to a vi-style mode, with a command mode reached by Escape. Readline is configured in ~/.inputrc: for example, set completion-ignore-case on makes filename completion ignore case, and you can bind keys to actions such as searching history with the up and down arrows. Because readline is a separate library, these settings also apply to other programs that use it, such as python3 and psql.

Practise: history and readline

Each question shows a history list, a setting or a readline key like the ones above. Decide what happens, then check your answer:

Interview questions

Warm-up (fresher to 2–5 years): how do you rerun your last command, and reuse just its last argument?

!! expands to the whole previous command, so sudo !! repeats it with sudo in front. !$ is the last word of the previous command, handy as mkdir reports && cd !$. Both are history expansion, done by the shell before the line runs, and both work only in an interactive shell. To find an older command, press Ctrl-R and type part of it; Bash shows the most recent match, which you run with Enter or edit first. The history list is numbered, so !n re-runs entry n, and history shows the numbers.

Two harder questions follow, about a history file that keeps losing commands and about a password that ended up in the history. Decide what you would check first, then open each first step:

Key takeaways

• Ctrl-R searches the history list as you type, and !!, !$ and !n pull a past command or a word of it into the current line before it runs.
• History expansion works only in interactive shells, so an ! in a script is harmless but an ! in double quotes at the prompt needs care.
• HISTCONTROL=ignoreboth skips duplicates and space-prefixed commands, and shopt -s histappend keeps several terminals from overwriting each other’s history.
• Readline edits the line with Emacs keys by default (set -o vi for vi keys), and ~/.inputrc configures it for Bash and every other program that uses readline.