Advancing in the Bash Shell (samrowe.com)

This is tight. Thanks for sharing, the history portion at the beginning is really cool.

I thought that i knew more than i actually know. Thanks!

Related: BASH FAQ - http://mywiki.wooledge.org/BashFAQ

Also, look at the screen tips by the same author - http://samrowe.com/wordpress/2010/06/16/gnu-screen-quick-tip...

I virtually never use !! any more. Instead I just type control-r followed by a portion of the command in my history that I'm interested in.

That's a much more interactive way of getting to the command I want, and if the first match isn't what I want I can either keep typing more of the command or type control-r for the next match. I can also type control-s to go to the previous match. For that last trick to work, you need to do something like this first: stty stop ""

Granted, I use zsh, but I think it works pretty much the same in bash.

Another trick I really like, which I've only used in zsh, but which might exist in bash too (since bash and zsh have so much feature parity these days) is to bind a keystroke to "insert-last-word". When this keystroke is hit, it appends the last argument of the previous command to the end of the current line, further typing of this same keystroke will remove the appended argument and instead append the last argument of the previous command, and so on. I use this all the time and therefore never have to type !$

And my favorite shell trick of all time: set -o vi

  # Put this in some file like ~/.readline-bindings
  "\e[A": history-search-backward
  "\e[B": history-search-forward

  # And this in your ~/.bashrc or ~/.zshrc
  bind -f ~/.readline-bindings

> Some people hold the belief that using a GUI is faster than using a CLI.

I've heard more people say this than that GUI is faster. Also it really depends on what you are doing.

I used to do !$ a lot until I configured iTerm to allow me to cycle through the last args with alt-. which is way faster. But I did not know about the colon modifiers, so !$ might make its way back into my workflow. ZSH gives me a nice overview of what's possible:

    > !$:<tab>
    &  -- repeat substitution
    A  -- absolute path resolving symbolic links
    Q  -- strip quotes
    a  -- absolute path
    c  -- PATH search for command
    e  -- leave only extension
    g  -- globally apply s or &
    h  -- head - strip trailing path element
    l  -- lower case all words
    q  -- quote to escape further substitutions
    r  -- root - strip suffix
    s  -- substitute string
    t  -- tail - strip directories
    u  -- upper case all words

Do you use Ctrl+R a lot? You should give fzf a try: https://github.com/junegunn/fzf

It works for both Vim & Bash.

I don't use !!, or !$, because I prefer to see what command is being executed before I press enter. For the same reason, I will never use !word. But that's not a problem, because as others have noted bash makes it easy to not have to fall back to these.

Alt-. will generally add the prior last argument into the current command, and repeated presses will cycle through previous commands.

Ctrl-r will dynamically update to show you the prior command matched as you start typing afterwards, so you can confirm it's correct.

Both are essential if you want to reuse prior commands but either can't trust that you were the last person using the shell, or don't want a typo to ruin your day, and possibly many other people's day as well. That is, if you're a sysadmin using the automatic variants, I don't want you anywhere near systems I rely on, I want you far away. Perhaps working for a competitor.

  $ yum install bash-completion
  Error: This command has to be run under the root user.
  $ sudo <Alt-.>
  $ sudo bash-completion

    #!/bin/bash

    echo -n "Are you SURE you dumbass? [N/y] " >/dev/stderr
    read -n 1
    if [ "$REPLY" = "y" ]; then
      echo >/dev/stderr
      exec /usr/bin/sudo "$@"
    else
      exec echo -e "\n:-)" >/dev/stderr
    fi

  shopt -s histreedit

    sudo !!:p

    > let myList = ["a", "b", "c"]
    > (myList !! 1, myList !! 2)

    parse error on input 'let'

    (myList (myList !! 1, myList !! 2) 1, myList (myList !! 1, myList !! 2) 2)

    (myList (myList (myList !! 1, myList !! 2) 1, myList (myList !! 1, myList !! 2) 2) 1, myList (myList (myList !! 1, myList !! 2) 1, myList (myList !! 1, myList !! 2) 2) 2)

    rm -rf ~/Pictures/Scans/NeedConverting/*

    rm -rf ~

I didn't realize that you could do something like: vim <(find . | grep coolfile) until just the other week, pretty dang useful.

    diff <(tar tzf f1.tgz) <(tar tzf f2.tgz)

    diff <(git diff --cached) the-patch-alice-proposed

One more handy one, when you have a complex command to deal with: C-x C-e will open up the current command line in your text editor, and when you save and quit, it'll run the line. So if you want to do some complex editing operation on the command line, you can do so with your preferred editor.

So happy to see this article get traction, it truly deserved it! Many unknown Bash tricks!

I featured it in the cron.weekly newsletter 2 weeks ago: https://www.cronweekly.com/issue-44/

I wonder how many people know a few of these (like ctrl-a and ctrl-e and other navigation commands) come not from bash per se but from readline[0]. It isn't a surprise, then, that these mirror emacs commands. For example, one I use often is ctrl-k to kill to the end of a line...and, yes, just like emacs, you can yank it back with ctrl-y too :)...I often do this if I type out a huge command, forget that I needed to type another before, so I use that to "save" commands before execution. That is, it's essentially cheap copy and paste on the commandline.

Cherry on top? These work on other readline using tools! They work in the interactive repl's like python, node, irb, ghcim the exact same shortcuts... it makes working with repl's much more pleasant for me.

[0] https://cnswww.cns.cwru.edu/php/chet/readline/rltop.html [1] quick note, node might use a readline like but it doesn't support yanking (pasting) unfortunately.

Another very useful feature related to brace expansion are sequences:

{1..99} will give 1 2 3 4 5 .. 9 10 11 12 .. 98 99

{01..99} will give 01 02 03 04 05 .. 09 10 11 12 .. 98 99

And so on. I think it also works with letters.

  $ echo {a..c}{1..5}
  a1 a2 a3 a4 a5 b1 b2 b3 b4 b5 c1 c2 c3 c4 c5

  $ echo {10..1}
  10 9 8 7 6 5 4 3 2 1

  $ echo {2..-002}
  0002 0001 0000 -001 -002

[Danger, do not try to run in your system] I like this :(){ :|: & };: which is a fork bomb http://askubuntu.com/questions/159491/why-did-the-command-ma...

Another good read:

Bash Shortcuts For Maximum Productivity [0]

[0] http://www.skorks.com/2009/09/bash-shortcuts-for-maximum-pro...

I like this article a lot. A lot of funny tricks to try and learn.

A missing piece of information IMHO: Ubuntu now maps a nice readline features to PgUp and PgDn: history-search-backward and history-search-forward.

Type the beginning of a command line, and with PgUp-PgDn, you will traverse your history for the command lines beginning with what you have typed.

That's a no-brainer in my Bash life.

Note: to enable that feature in your Bash, here is a tutorial: http://dqxtech.net/blog/2011-03-06/linux-bash-history-pgup-p...

I know of "M-." which will insert the last word of the previous command, and typing "M-." again will replace it with the last word of the command before that.

Is there something that goes through the words, instead? So I hit a key, it inserts the last word of the previous command, then I hit the key again and it replaces it with the penultimate word of the previous command?

I think using bang, I can do "!-3:1" to get the second word of the command three lines up?

I use fish. It's not a popular choice of a shell, but the autosuggestions feature saves a LOT of time.

My best progress in shell was by switching to Fish. Much more intuitive for programmer. Guess what this does:

  while true
    clear
    df
    sleep 1
  end

  while sleep 1; do
    clear
    df
  done

    while true; do
        clear
        df
        sleep 1
    end

History manipulation in bash only reminds me why I have both the current commands history number and the last return code in my prompt.

I don't need colors, or anything fancy in my prompt, but those two things I find to be really useful.

  export PS1='[\u@\h \W](\!/$?)$ '

I almost never use any of the "shortcuts" explained. And I wonder if it would be worth learning them. They look much more cumbersome than the alternatives, I use in my everyday work.

I have to admit, that -- at some time in the past -- I've even tried to activate vim mode. As a heavy vim user i thought it would make sense.

At the end I'm stuck with the Emacs-inspired (is it really Emacs?) shortcuts.

They seem to be the ones that make most sense in the short living, very interactive, shell command line:

- Arrows for going up/down one or two commands,

- ctrl-r for interactive searching in the history,

- ctrl-a for going back to the beginning of the row,

- ctrl-e to the end,

- del & and backscape for deleting a bunch of chars,

- in some case ctrl-w for deleting words backwards (mostly for deleting the url in the latest wget command),

- and, of course, tab completion.

When I'm in need for more complex interactions:

- I start vim and

- work with a mix of !! commands (shell that outputs the result in the current vim buffer),

- vim manipulations (vertical selections, ctrl-x-f, qq short living macros), A and I with a . repeat),

- join everything in a row and yank it and, finally,

- a :!ctrl-r" to run it.

When the interaction is even more complex, than it's time for a shell script.

Last resort being a Python script.

Now, why would I take the time to write `rm my-file{-01,-02,old}` and risk getting a typo into it, instead of relying on the tab-autocomplete?

  $ C-x C-e
  # in vim
  ipushd dir
  do stuff
  popd
  <esc>:wq

^a I would remember it

Did you know Ctrl + / is like undo while composing a command? So when you for example delete a word with Ctrl + W, you can get it back with Ctrl + /.