Sstrhsrtj

Most shells that have a command line editing feature
support Emacs key bindings. (a tiny subset)

Up     Ctrl+P

Down   Ctrl+N

Left   Ctrl+B

Right  Ctrl+F

Home   Ctrl+A

End    Ctrl+E

Delete Ctrl+D

Alternatively, you could set up your shell to use vi command editing mode, by adding set -o vi to your shell startup file (e.g., ~/.bashrc). 
Then, for example, you can

• Use EsckEnter
  to re-execute the previous command (same as !!). 
  The minus key - also works as a "move up" command.


• Use EsckkkkkkkkkkkkEnter
  or Esc12kEnter
  to re-execute the 12th previous command (same as !-12).


• Use Esc and a motion command
  (i.e., k, suitably repeated),
  and then edit the bash command line you find there. 
  Remember, you will still be in vi command mode,
  so you will need to use a vi editing command
  (e.g., I, A, C, R,
  or one of their lowercase counterparts)
  to actually add to the command from history.
  
  So, for example, EsckisudoSpaceEnter is equivalent to sudo !!.


• For advanced users: you can even copy (yank) text from one line
  and paste (put) it on another,
  so you can accomplish results comparable to !-2:- !$. 
  (Unfortunately, it does not seem to support named buffers.)

My favorite one is CTRL + P then CTRL + O

This works by default, no extra configuration needed. ^P will let you switch to the last command and ^O will let you execute current line

Note that CTRL + O can be used for as many times as you want

Sure! Since you're used to vi keybindings, why not configure your shell to respond to them? For bash, put this in your ~/.inputrc:

set editing-mode vi

Running instances of bash will not re-read the file, so log out and back in.

zsh will even detect this for you: if none of your startup scripts force the editing mode one way or the other using bindkey and if your $EDITOR environment variable is detected to contain vi, then it will automatically enable vi keybindings. If you need to force it, put this in your ~/.zshrc:

bindkey -v

Thereafter, use ESC as usual to enter command line and k and j to move up and down.

ALSO: The default shell bindings in most shells are the emacs bindings, so actually Crtl-P and Ctrl-N should already work without you having to change anything.

With any POSIX shell implementing the User Portability option (includes ksh, zsh, bash, yash), you can also use the fc command:

fc -e : -1

See an example:

$ echo "hello"

hello



$ fc -e : -1

echo "hello"

hello

More info in Execute a range of commands from history's answer by Jonathan Leffler.

I find I need to redo commands as super user often, so

sudo !!

redoes the previous command as if I had remembered to type sudo in the first place.

For all you Mac iterm2 users:

You can bind ⌘+R to 0x0C 0x10 0x0d. This will clear the terminal and run the last command.

With csh or any shell implementing csh-like history substitution (tcsh, bash, zsh), you can also use the !<beginning of command> to call the last command beginning with <beginning of command>.

for example if you ran

$ tail file.txt

$ less otherfile.txt

$ !ta

!ta would execute tail file.txt

The ksh shell has a default alias r that repeats the most recent command. It is bound to fc -s:

alias r='fc -s'

Interestingly, the bash documentation for the fc builtin (help fc, and also in the manual itself) even mentions this, but it's not a default alias in that shell:

A useful alias to use with this is r='fc -s', so that typing r cc
runs the last command beginning with cc and typing r re-executes
the last command.

In bash, this would also work even if you have turned history expansions off with set +H.

In the zsh shell, there is a r builtin that is documented to be the same as fc -e -.

The fc utility is a POSIX standard utility.

When I am using a good xterm emulator, e.g. putty, my favorite way to proceed is to select the command including line feed, copy it to clipboard and then use right click on the mouse to paste it. This repeats the command in a single click.
This also works fine for a sequence of commands separated by semi-colons.

tl;dr !! just appends the last command to your current command. <backtick>!!<backtick> executes the last command and appends the output to your current command.

There are actually 2 variants:

1. The last command itself


2. The result of the last command

Let me show you 2 examples:

Example 1

$ mkdir /test

mkdir: /test: Permission denied



$ sudo !!

sudo mkdir /test

Password:

As you see above, I'm executing a command and essentially just appending the last command.

Another variation

Example 2

$ find ~/Documents "test.txt"

/Users/<user>/Documents/test.txt



$ vi `!!`

# Opens test.txt. But if you do

$ vi !!

vi find ~/Documents -name "test.txt"

VIM - Vi IMproved 8.1 (2018 May 18, compiled Oct 29 2018 06:55:58)

Unknown option argument: "-name"

More info with: "vim -h"

• Type History and note the number in front of the command that you to
  execute and use !number




• You can also use !-1 (1 being the last command you execute, replace
  it with the count number that you get when you do it from below
  keeping the last executed as 1 )



• 
  !-2 (second last and so on)

you can use !n to execute nth command in terminal.
where 'n' is line no of history command.