Bash Shortcuts For Maximum Productivity

http://www.skorks.com/2009/09/bash-shortcuts-for-maximum-productivity/

by pooriaazimi • 15 years ago

181 56 15 years ago

pooriaazimi2• 15 years ago

A note to Mac users: Instead of Alt, you must press escape key. For example, Esc+b moves the cursor backward one word in bash, but you'll probably want to use option instead, so check 'Use option as meta key' in Terminal's settings (under keyboard tab).

But if it's not very handy, you can set 'option+left arrow' to move cursor one word backward. To do that, open Terminal's settings, go to keyboard and add a shortcut for left arrow (with 'option' as modifier), and leave the action to 'send string to shell'. Then click on the textbox below that and press esc (which should print '\033') and then 'b', or simply type '\033b' in the textbox.

Just this simple shortcut makes Mac's Terminal 1000 times better.

spatten• 15 years ago

Totally agreed.

I also have 'option+right arrow' mapped to move cursor one word forward (use the same instructions as above, substituting 'f' for 'b').

ghshephard• 15 years ago

Thanks very, very much. I'm embarrassed to admit I probably spend 3-5 hours a day on a command line, and have just gotten used to set -o vi when I need to bounce around long lines a lot. esc+f/esc+b were always awkward. It should have occurred to me to just map the keys on Terminal.app!

In the interesting news department - Lion already has option left cursor/right cursor already mapped to move a word forward and back - not sure if it was there in snow leopard.

raju• 15 years ago

I am iTerm user so for those folks here is the setup you need to make "option" key the 'meta' key in iTerm

http://stackoverflow.com/questions/196357/making-iterm-to-tr...

I still don't like it since I am so used to hitting the Apple key in emacs, but it beats having to use Esc+<letter>

dhugiaskmak• 15 years ago

I've been using this[1] page as a cheatsheet for readline commands.

[1] http://jan.tomka.name/sites/default/files/readline-commands....

andrewflnr• 15 years ago

One of my favorite bash shortcuts is binding the up arrow to history-search-backward. This is the first page I found that concisely explains how; the variant in the second comment is the one actually in my .bashrc:

http://hints.macworld.com/article.php?story=2003102617423686...

So if you've typed `verylongcommand` some indeterminate time in the past, you can probably just type "ver<up>", and you'll have it. Very convenient.

irahul2• 15 years ago

A quick look at the article shows it's binding history search. It's already bind to ctrl-r - you can do a ctrl-r, type a few letters of the long commands, and keep doing a ctrl-r till you find the right match.

Apart from additional bind your setup requires, arrow keys are near impossible to touch type. Even if you can touch type them, that means taking your hands off the home row, and positioning them again.

bostonvaulter2• 15 years ago

I think with the parent's setup you can do ver<C-p> to get the same effect.

graywh3• 15 years ago

I use ctrl-P/N for history-beginning-search-{backward,forward} in Zsh. Type the start of a previous command and cycle through the matches.

tedkalaw• 15 years ago

I'm not an Emacs user, but aren't a lot of the text-editing shortcuts straight from Emacs?

aerique• 15 years ago

Yup, but you can also put Bash in a vi mode. Some else will to chip in with the exact incantation, since I'm on my phone now.

pyre2• 15 years ago

  set -o emacs

  set -o vi

irahul2• 15 years ago

The text editing shortcuts are straight from readline http://cnswww.cns.cwru.edu/php/chet/readline/rltop.html emacs bindings, which bash and many other programs use. readline supports both vi and emacs bindings.

I am a dyed in the wool vim enthusiast, but when it comes to command line bindings, emacs' bindings are more convenient.

unfletch• 15 years ago

The things he calls "bang commands" are actually "event designators" (!!, !blah), "word designators" ($) and "word modifiers" (:p). There are links to docs for each at the bottom of this page: http://www.gnu.org/s/bash/manual/html_node/History-Interacti...

I use them all the time, and anyone watching over my shoulder always asks what that was. Learn !!, !$, and a few modifiers. You'll be glad you did. Personally, I use !$ constantly (and variations like !-2$, which gets you the last arg from 2 commands ago). The "h" modifier is handy, too. It's like dirname for the word. Consider this example, where you copy a file to some deep path, and then cd to that dir to continue working with the copy:

    $ cp foo.txt /some/really/long/destination/bar.txt
    $ cd !$:h
    $ # (do more with ./bar.txt)

The substitution (:s) and global substitution (:gs) modifiers are also useful:

    $ echo some args
    some args
    $ !!:s/some/more
    more args

(Also, note that his explanation of !* is actually incorrect. He says it leaves off the last arg, but actually leaves out $0 (the command name). !* is all of the previous command's arguments.)

Finally, one really useful thing he doesn't mention at all is brace expansion. For example, these are equivalent:

    $ cp foo.conf foo.conf.bak
    $ cp foo.conf{,.bak}

http://www.gnu.org/s/bash/manual/html_node/Brace-Expansion.h...

pyre2• 15 years ago

A neat thing about csh/tcsh is that you can use history expansion with aliases. There are some legacy aliases at work that allow SQL queries from the command line using this:

  $ alias select='sqlcommand -s "select !*"'

would translate:

  $ select * from tablename

to:

  $ sqlcommand -s "select * from tablename"

(Note: I may be getting the specifics messed up as it's been a couple of years since I looked at the implementation, but the general idea is there.)

drothlis• 15 years ago

I used to use !$ all the time, but these days I tend to go for M-. which inserts the last argument interactively, and cycles through the last argument of all previous commands (but you don't get modifiers like !$:h).

http://www.gnu.org/s/bash/manual/html_node/Commands-For-Hist...

M-C-y (yank-nth-arg) works similarly for the first argument of the previous command, but without cycling through all previous commands.

After the more complex modifiers like !$:p, :e, :s/old/new/, etc, before hitting Return I often use M-C-e (shell-expand-line) just to check I got it right.

http://www.gnu.org/s/bash/manual/html_node/Miscellaneous-Com...

pooriaazimi2• 15 years ago

Thank you! The backup tip was great. I never thought of using expansion like that...

You post inspired me to quickly create two (hopefully) handy bash functions:

  # Create a backup of the given file(s)
  # USAGE: bk file1 file2 file3
  #        -> result: file1.bak file2.bak file3.bak
  bk() {
  for file in "$@"
    do
      cp $file{,.bak}
    done
  }

  # Restores the file from backup
  # USAGE: rbk file.bak OR rbk file
  #        -> result: replaces file with file.bak
  rbk() {
    if [[ $1 == *.bak ]]
    then
      backup_file=$1
      old_file=${backup_file:0:$((${#backup_file}-4))}
    else
      old_file=$1
      backup_file=${old_file}".bak"
    fi

    read -p "Replace the old backup? (y/N) " -n 2
    echo
    if [[ $REPLY =~ ^[Yy]$ ]]; then
      `cp $backup_file $old_file`
    fi
  }

I've put them in my newly created .functions file (https://github.com/pooriaazimi/dotfiles/blob/master/.functio...).

gbog• 15 years ago

!! and !$ are alright, but I really dislike !blah, which is blindly executing the latest command starting with blah, whatever it is. The author of the article should remove this "tip", it is bad advice, or at least make a note that the !blah:p is highly preferable.

spiffytech• 15 years ago

I prefer using Ctrl-r <blah>, which searches your history for 'blah' and puts it on the command line. The preferable part is that you can keep hitting Ctrl-r to see previous matches, which is often helpful since you don't want the last match, but the second or third match.

apu• 15 years ago

A small change that made it much easier for me to use ! commands was enabling magic space, which expands the ! macros out when you press space. This made an enormous difference to me, since I could now be sure I wasn't accidentally completing the wrong command or arguments.

To enable it, edit your .inputrc (this is part of readline) and add this:

  $if Bash
    Space: magic-space
  $endif

mrud• 15 years ago

I am using follow function for cd which does basically the same though i can iterate through the last arguments with alt+.

    cd () {
	if [[ -f $1 ]]
 	then
		builtin cd $1:h
    	else
    		builtin cd "$@"
    	fi
    }

arckiearc3• 15 years ago

Great tips. !! is a nice timesaver when you've forgotten to prepend sudo to a command:

  $ /etc/init.d/rabbitmq-server restart
  Failed, need root access
  $ sudo !!
  Success

cd - is also quite cool, it takes you to the previous working directory.

  $ pwd
  /some/really/long/path/goes/here
  $ cd /var/log/app
  Work in this directory for a while, then go to previous dir
  $ cd -
  $ pwd
  /some/really/long/path/goes/here

joshu• 15 years ago

Don't forget pushd and popd.

graywh3• 15 years ago

For Zsh, setopt autopushd

gommm• 15 years ago

I have the following in my zshrc for sudo. It adds sudo at the beginning of the current line or writes sudo !! if the current line is empty. I've aliased it to alt+s

    run-with-sudo() {
      if [[ -z $LBUFFER ]]; then
        LBUFFER="sudo !!";
      else
        LBUFFER="sudo $LBUFFER";
      fi
    };
    zle -N run-with-sudo;
    bindkey '\es' run-with-sudo

arckiearc3• 15 years ago

Nice little timesaver for such a common task, I'd just been doing the following (with vi editing on) but yours is much easier:

  esc-0-i-sudo

dongsheng2• 15 years ago

I use `..` to go upper directory, `...` to go up two levels, I added this to bashrc:

  str='..'
  level='./../'
  for i in `seq 1 10`;
  do
      eval "alias '$str=cd $level'"
      level=$level'../'
    str=$str'.'
  done

Note, seq is not available in Mac, should use jot instead.

imurray• 15 years ago

There's no need for seq or jot. In bash you can replace `seq 1 10` with {1..10}. Or {01..10} if you want zero padding when using $i to label files.

I use an function called "up" that takes an optional integer argument to go up a certain number of levels. It won't necessarily be faster, but somehow I prefer it to typing lots of dots in a row:

   function up () { if test $# = 1 ; then s=$( printf "%$1s" ); s=${s// /..\/}; cd $s ; else cd .. ; fi; }

dongsheng2• 15 years ago

Thanks for pointing out that

kleiba• 15 years ago

It's well known that !! is a sweet little helper in case where you forgot to sudo a command. However, I find that for those cases I usually use `Up-arrow CTRL-A` to get the previous command and then go to the beginning of the line where I can type `sudo`. Is there any reason to prefer the !! variant?

yanowitz• 15 years ago

I do too.

I think it's faster than a cycle of :p, verify it's what you want and then reexec. It's also mentally less taxing (albeit a tiny amount). But summed over a day of shell work, I think it makes a difference.

ajross• 15 years ago

If you're on a non-interactive terminal. Some of us didn't throw out our teletypes. Also: when rooting boxes often one lacks space in the exploit payload to set up the tty line discipline.

secoif• 15 years ago

commandline and vim have easily got the most powerful, yet the most rage-inducing key mappings – ever.

The worst, and most easily rectifiable aspect is the way command pairs (eg move back/forward a word) require two totally separate commands (esc + b/esc + f) instead of having one command + a generic 'reverse' meta key.

In the future I hope someone has the balls to do away with this legacy tripe and popularise some more Donald-Normanesque keyboard shortcuts.

spacemanaki• 15 years ago

I'm not sure if you're just trolling, but I don't understand your complaints at all. What would your "Donald-Normanesque keyboard shortcuts" even look like? In Windows the arrow keys act pretty similar, don't they? left-arrow, right-arrow for moving by character, Ctrl-left-arrow, Ctrl-right-arrow for moving by word. Windows is about as Donald-Normanesque as you can get...

The bash shortcuts are from readline, which (in this case, but by default?) are the same as Emacs. C-f,C-b for moving by character, M-f,M-b for moving by word. C-n,C-p for next and previous line. I think there's a vi switch for readline which would allow you to have vi style shortcuts in bash. This is nice, because it means you have one set of keyboard shortcuts in your editor and shell. Emacs users in OS X get this in any text box (at least any that supports the same defaults as the system, I'm spitting at you MS Outlook/Entourage). I'm sure you could set something up in other windows systems, like GNOME or KDE.

Sure the keyboard shortcuts might be cryptic, but any keyboard shortcuts will be. Don't slag something just because you don't know the history and background behind the choices.

gaving2• 15 years ago

I'm a zsh user, but here's a couple of things I find pretty invaluable:-

    bindkey '^Q' push-line

The 'push-line' widget allows you to quickly type another command and will restore the previous one once you've entered it.

    # re-run the previous command with sudo
    rerun-with-sudo () {
      LBUFFER="sudo !!"
      zle accept-line
    }
    zle -N rerun-with-sudo
    bindkey '^Xx' rerun-with-sudo

Re-run the previous command prefixed with sudo by typing ^X then x.

And:-

    # build git clone command from clipboard
    git-clone-clipboard() {
        REPO_URL="$($CLIPBOARD)"
        REPO_BASE_NAME=${$(basename $REPO_URL)%.git}
        LBUFFER="nocorrect git clone $REPO_URL $REPO_BASE_NAME"
    }
    zle -N git-clone-clipboard
    bindkey "^Xg" git-clone-clipboard

^Xg prefixes a git url with "git clone" and fills out the command line.

Couple similar things for wget, youtube-dl here: https://github.com/gaving/dotfiles/blob/master/.zsh/config

pmr_• 15 years ago

If I have a URL in my clipboard and want to prefix it I use:

    git clone `xclip -o`

Much simpler and no customization needed.

gaving2• 15 years ago

uh, why wouldn't you just actually paste the url into your terminal at that point instead of typing `xclip -o`?

and yeah, typing the actual command into the terminal is always going to be 'simpler'

tednaleid• 15 years ago

I'm also a big zsh user, one of the biggest timesavers for me was to get autocompletion of the arguments from the last command working. I use meta-. for the last argument, but !:# syntax is awkward and I don't often remember exactly what number parameter something was. Took a bit of screwing around, but I eventually figured it out and the details are on the unix/linux stack exchange site: http://unix.stackexchange.com/questions/5229/add-arguments-f...

dramaticus3• 15 years ago

the best bash shortcut you could do

    # ln -s /usr/local/plan9/bin/rc /bin/bash

pkrumins2• 15 years ago

I am a huge fan of maximizing productivity in the shell. I wrote these three articles a while ago:

Bash emacs-like keyboard shortcuts:

http://www.catonmat.net/blog/bash-emacs-editing-mode-cheat-s...

Bash vi-like keyboard shortcuts:

http://www.catonmat.net/blog/bash-vi-editing-mode-cheat-shee...

Definitive bash guide to command line history:

http://www.catonmat.net/blog/the-definitive-guide-to-bash-co...

And they all come with cheat sheets. See downloads box at the bottom of each post for download links.

dave1010uk• 15 years ago

Great articles. I'm just starting to get into the hang of vi. I'm giving vi-mode in bash a go (with "set -o vi") but there doesn't seem to be any indication of when I'm in command/insert mode. Is there any way to see this?

pkrumins2• 15 years ago

I don't know of a way to do it.

mun2mun• 15 years ago

There is a workaround in zsh http://superuser.com/questions/151803/how-do-i-customize-zsh...

graywh3• 15 years ago

The vi-mode is actually provided by readline, so bash has no knowledge of it. So, no.

montecarl3• 15 years ago

Sometimes I find myself typing out a long command and then deciding that I don't want to run it quite yet. Normally I just hit C-c run some other command first and then copy paste the long command. Surely there is someway to put the long command in history?

gnubardt• 15 years ago

Comment it out (put a # at the front), unless your shell is set to ignore commented lines.

montecarl3• 15 years ago

This works great! There is even a shortcut: M-#

veyron• 15 years ago

Cheatsheet for emacs mode (which is what the article presumes): http://www.catonmat.net/download/readline-emacs-editing-mode...

Azrathud• 15 years ago

Most of the commands there can be replaced with vi keybindings.

That is, set -o vi

You can type that directly into your terminal for use just in one session or in your .bashrc

Type <C-]> or <Esc> just like in vim to escape into "command" mode. Most command mode commands work. E.g. '^' goes to the beginning of the line '$' goes to the end. 'i' sets bash back into insert mode.

Ideka• 15 years ago

Try Alt-*

    ls /etc/p<Alt-*>

super_mario• 15 years ago

These assume you use default emacs mode. If you are vi/vim user then set -o vi will allow you to get immediately productive in bash, using vi motion commands to edit the command line.

Bash Shortcuts For Maximum Productivity

Related Stories