How can I recall a command from history by number without executing it?

Question

How can I grab a command from history by number to my command line without executing it?

This immediately executes command number 555 which I'm not looking for:
$ history 10
$ !555

This opens the command up in an editor, which is overkill most of the time:
$ history 10
$ fc 555

This is an example of what I'm looking for:
$ history 10
$ #555
$ [command 555 from history listing now sitting here on my command line ready to edit or execute]

Thank you!

Answer 1

shopt -s histverify

If the histverify shell option is enabled, and Readline is being used, history substitutions are not immediately passed to the shell parser. Instead, the expanded line is reloaded into the Readline editing buffer for further modification.

Answer 2

Add :p after the digits.

Example:

1357  locate pam_loginuid
1358  history
rinzwind@discworld:~$ !1358:p
history
rinzwind@discworld:~$ !1357:p
locate pam_loginuid
rinzwind@discworld:~$ 

Printed to display and not executed.

For using it in BASH you need to do more. Example:
https://tldp.org/LDP/abs/html/histcommands.html

#!/bin/bash
set -o history
var=$(history); echo "$var"   # 1  var=$(history)`

will put all of history into var and you need some more logic to find the command you want.

Answer 3

If you are using bash, which I presume you are; Type the history number:

$ !555

Then Press: Ctrl + Alt + e, Now the desired command from history is sitting in your prompt waiting to be executed without changing the default behavior of history:

$ command

It also works for aliases, substitutions, expansions and arguments of history say: $ echo !555:1, ~, $HOME, $(echo hi).

---

This is how I make sure exactly what command from history will be executed before actually running it.

Answer 4

edit: I mistakenly said at first "ctrl-f" where it is in fact "ctrl-r" ... (which I use multiple times a day). I edited the correct commands now ...

Not the method you asked, but probably good for what you seem to need to do (ie, find a previous line in history and edit it before entering/executing it again):

# in bash
[Ctrl]+r  Foo 
# This recalls the previous history line containing Foo, in edit mode.
# You can then:
# [Enter] to execute it "as is", and returns to prompt.
#  -or- [Ctrl]+o executes it "as is" + presents the following
#       history line, ready to be executed
#  -or- <Leftarrow> or <Rightarrow> makes that line the current one
#         and you can then edit it before executing it (what OP asked for)
#  -or- [Ctrl]+c to return to the prompt without executing 
#        the currently displayed command line.
#  -or- another [Ctrl]+r search the previous occurrence of Foo
   

That way no need to do history and figure out which history number you needed to edit and another combination to actually retrieve and edit it: [Ctrl]+r Something will find the previous line(s) containing Something for you and present it in edit mode. It is much faster, in general.

Ctrl-o (instead of enter) is especially usefull if you often need to edit 1 command and follow it by a repeat sequence of commands

And nice bonus: this ctrl-r, etc : is often available in other programs (ex: mariadb-server cli [ usefull to retrieve the last 'use' command] , and probably many others). It is probably based on (maybe offered by, or at least using) the "readline" mechanism, but I do not know the details...

Answer 5

• You can use the bash built-in command read directly like so:

  read -e -i "!555" -p "${PS1@P}" input; $input
  

• Or you can add it in a function to your ~/.bashrc like so:

  showhist() {
  
          read -e -i "$*" -p "${PS1@P}" input
          $input
  
  }
  

  and use it like so:

  showhist !555
  

That will show the command at the prompt and you can edit it.... Enter to execute or Ctrl+c to abort.