We all know how to use <ctrl>-R to reverse search through history, but did you know you can use <ctrl>-S to forward search if you set stty stop ""? Also, have you ever tried running bind -p to see all of your keyboard shortcuts listed? There are over 455 on Mac OS X by default.

What is your single most favorite obscure trick, keyboard shortcut or shopt configuration using bash?

+3  A: 

Well, this may be a bit off topic, but if you are an Emacs user, I would say "emacs" is the most powerful trick... before you downvote this, try out "M-x shell" within an emacs instance... you get a shell inside emacs, and have all the power of emacs along with the power of a shell (there are some limitations, such as opening another emacs within it, but in most cases it is a lot more powerful than a vanilla bash prompt).

Mike Stone
As a side note, I can barely stand a shell now without it being inside Emacs.
Mike Stone
And as a side-note, I can barely stand a shell once it *contains* Emacs... seriously, how does a salty vim user get to know emacs?
Gregg Lind
And if you are a Python user, iPython (no, not an Apple product) is good too. All the power of Python with the power of a shell. Now if you are a Python and Emacs user, run iPython from Emacs.
+12  A: 

You can use the watch command in conjunction with another command to look for changes. An example of this was when I was testing my router, and I wanted to get up-to-date numbers on stuff like signal-to-noise ratio, etc.

watch --interval=10 lynx -dump http://dslrouter/stats.html
The watch command is really cool. I first read about in the Linux Server Hacks book about five years ago. Who knew it existed?
What in the world does 'watch' have to do with bash?
Artem Russakovskii
+22  A: 

More of a novelty, but it's clever...

Top 10 commands used:

$ history | awk '{print $2}' | awk 'BEGIN {FS="|"}{print $1}' | sort | uniq -c | sort -nr | head

Sample output:

 242 git
  83 rake
  43 cd
  33 ss
  24 ls
  15 rsg
  11 cap
  10 dig
   9 ping
   3 vi
Here's a shorter, faster version: `history | awk 'BEGIN {FS="[ \t]+|\\|"} {print $3}' | sort | uniq -c | sort -nr | head`
Dennis Williamson
+105  A: 
cd -

It's the command-line equivalent of the back button (takes you to the previous directory you were in).

Mark Biek
I prefer to use `pushd` and `popd` to maintain a directory stack, myself.
But 'cd -' has the advantage of working even if you didn't remember to use pushd.
Sergio Acosta
It's worth mentioning that 'cd' takes you to your home directory.

bash can redirect to and from TCP/IP sockets. /dev/tcp/ and /dev/udp.

Some people think it's a security issue, but that's what OS level security like Solaris X's jail is for.

As Will Robertson notes, change prompt to do stuff... print the command # for !nn Set the Xterm terminal name. If it's an old Xterm that doesn't sniff traffic to set it's title.

Tim Williscroft
+3  A: 

I like a splash of colour in my prompts:

export PS1="\[\033[07;31m\] \h \[\033[47;30m\] \W \[\033[00;31m\] \$ \[\e[m\]"

I'm afraid I don't have a screenshot for what that looks like, but it's supposed to be something like (all on one line):

[RED BACK WHITE TEXT] Computer name 
[BLACK BACK WHITE TEXT] Working Directory 

Customise as per what you like to see :)

Will Robertson
I went with export PS1="\[\033[06;32m\] \h \[\033[42;30m\] \W \[\033[00;31m\] \$ \[\e[m\]" - looks pretty nifty!
Will Bickford
+7  A: 

When downloading a large file I quite often do:

while ls -la <filename>; do sleep 5; done

And then just ctrl+c when I'm done (or if ls returns non-zero). It's similar to the watch program but it uses the shell instead, so it works on platforms without watch.

Another useful tool is netcat, or nc. If you do:

nc -l -p 9100 > printjob.prn

Then you can set up a printer on another computer but instead use the IP address of the computer running netcat. When the print job is sent, it is received by the computer running netcat and dumped into printjob.prn.

Why this and not, for example, `wget`?
Try `watch ls -la <filename>` (use -n5 if you don't like the default of 2 seconds).
Ted Percival
@Ted, `watch` is not available on all platforms though, like Solaris, Mac OS X, [email protected], not sure what you mean. Can wget also listen on a port?

Some useful mencoder commands I found out about when looking for some audio and video editing tools:

from .xxx to .avi

mencoder movie.wmv -o movie.avi -ovc lavc -oac lavc

Dump sound from a video:

mplayer -ao pcm -vo null -vc dummy -dumpaudio -dumpfile fileout.mp3 filein.avi
Sergio Morales
+30  A: 

[ESC key and then dot]. Inserts the last arguments from your last bash command. It comes in handy more than you think.

cp file /to/some/long/path
cd <esc>-.
Does not work for me.
Allan Wind
Or me (using zsh :)
This works for me (bash). Note that you hit the esc key and then the period key. No hyphen or anything.
Also alt-. is the same thing.
Mark Baker
Yeah, it's Bash only. But <esc> (or Alt- or Meta-) _ is bound to the same function, and <esc>-_ also works in vi-mode too.
Nick Dixon
@hendry in my zsh it actually works. Maybe you use vi mode?
+38  A: 

When running commands, sometimes I'll want to run a command with the previous ones arguments. To do that, you can use this shortcut:

$ mkdir /tmp/new
$ cd !!:*

Occasionally, in lieu of using find, I'll break-out a one-line loop if I need to run a bunch of commands on a list of files.

for file in *.wav; do lame "$file" "$(basename "$file" .wav).mp3" ; done;

Configuring the command-line history options in my .bash_login (or .bashrc) is really useful. The following is a cadre of settings that I use on my Macbook Pro.

Setting the following makes bash erase duplicate commands in your history:

export HISTCONTROL="erasedups:ignoreboth"

I also jack my history size up pretty high too. Why not? It doesn't seem to slow anything down on today's microprocessors.

export HISTFILESIZE=500000
export HISTSIZE=100000

Another thing that I do is ignore some commands from my history. No need to remember the exit command.

export HISTIGNORE="&:[ ]*:exit"

You definitely want to set histappend. Otherwise, bash overwrites your history when you exit.

shopt -s histappend

Another option that I use is cmdhist. This lets you save multi-line commands to the history as one command.

shopt -s cmdhist

Finally, on Mac OS X (if you're not using vi mode), you'll want to reset <CTRL>-S from being scroll stop. This prevents bash from being able to interpret it as forward search.

stty stop ""
I find "Alt-." much better than "!!:*" for repeating the last word of the last command.
Additions for histroy:1. regularly save history (with -a if you have multiple shells open at once)export PROMPT_COMMAND="history -a"2. Alias for reading the history from other shells.alias -- h='history -n ; history | grep '
export HISTIGNORE="[ ]*" is not necessary, as your HISTCONTROL=ignoreboth should do the same
Another nice thing for history:export HISTTIMEFORMAT="%Y-%m-%d %H:%M:%S : "
To save a few keystrokes off of "cd !!:*", try "cd !$". The "!$" will be interpreted as the last argument of your last command.
Tim Stewart
+36  A: 



$ ls

$ rename 's/text_to_find/been_renamed/' *.txt
$ ls

So useful

Wow, I've been a moron all these years using basename, mv and {} tricks to do this. /foreheadsmack.
Gregg Lind
rename isn't bash/readline specific like the other posts however.
zmv from zsh distribution is much better in most cases.
+105  A: 

Another favorite:


Repeats your last command. Most useful in the form:

sudo !!
it has the added benefit of making you sound really angry about it too."Computer, do this.""Access denied"."DO IT!!"
That's not little known! :-)
Similar things you can do: `mkdir testdir; cd !$`.. This runs `cd [last word of previous line]` (in the example, `cd testdir`)
Make Me A SandwichSudo !!
sudo sounds japanese too. I can perfectly picture an angry samurai yelling it before brandishing his katana. "SUDO !!"
If you like !!, !$ and !-1:^foo^bar, you'll also "bind Space:magic-space".
+9  A: 

I like to construct commands with echo and pipe them to the shell:

$ find dir -name \*~ | xargs echo rm
$ find dir -name \*~ | xargs echo rm | ksh -s

Why? Because it allows me to look at what's going to be done before I do it. That way if I have a horrible error (like removing my home directory), I can catch it before it happens. Obviously, this is most important for destructive or irrevocable actions.

Jon Ericson
You might want to use find -print0 and xargs -0 to avoid problems with files and folders with white spaces in them.
Or avoid creating and working with files and folders with white spaces in their names. ;-) Obviously if you are working with user generated names, your suggestion is vital.
Jon Ericson
Why would you append "| ksh -s" when you could just remove the "echo"?
+14  A: 

Here's a couple of configuration tweaks:


"\C-[[A": history-search-backward
"\C-[[B": history-search-forward

This works the same as ^R but using the arrow keys instead. This means I can type (e.g.) cd /media/ then hit up-arrow to go to the last thing I cd'd to inside the /media/ folder.

(I use Gnome Terminal, you may need to change the escape codes for other terminal emulators.)

Bash completion is also incredibly useful, but it's a far more subtle addition. In ~/.bashrc:

if [ -f /etc/bash_completion ]; then
    . /etc/bash_completion

This will enable per-program tab-completion (e.g. attempting tab completion when the command line starts with evince will only show files that evince can open, and it will also tab-complete command line options).

Works nicely with this also in ~/.inputrc:

set completion-ignore-case on
set show-all-if-ambiguous on
set show-all-if-unmodified on
+1 bash_completion is awesome
+2  A: 

As an extension to CTRL-r to search backwards, you can auto-complete your current input with your history if you bind 'history-search-backward'. I typically bind it to the same key that it is in tcsh: ESC-p. You can do this by putting the following line in your .inputrc file:

"\M-p": history-search-backward

E.g. if you have previously executed 'make some_really_painfully_long_target' you can type:

> make <ESC p>

and it will give you

> make some_really_painfully_long_target

Since using this key with nothing on the command line will act like "previous-history", I use this function to replace the "ctrl-P" behavior. If I use ctrl-p on a blank line it pulls up the previous ocmmand. If I start typing first, it will complete it. Additionally, the previous-history function will show you multiple copies of the same command if you typed it multiple times. The history-search-backwards function will compress those and only show you one command for each repeated group.
Chris Quenelle
+49  A: 

I'm a fan of the !$, !^ and !* expandos, returning, from the most recent submitted command line: the last item, first non-command item, and all non-command items. To wit (Note that the shell prints out the command first):

$ echo foo bar baz
foo bar baz
$ echo bang-dollar: !$ bang-hat: !^ bang-star: !*
echo bang-dollar: baz bang-hat: foo bang-star: foo bar baz
bang-dollar: baz bang-hat: foo bang-star: foo bar baz

This comes in handy when you, say ls filea fileb, and want to edit one of them: vi !$ or both of them: vimdiff !*. It can also be generalized to "the nth argument" like so:

$ echo foo bar baz
$ echo !:2
echo bar

Finally, with pathnames, you can get at parts of the path by appending :h and :t to any of the above expandos:

$ ls /usr/bin/id
$ echo Head: !$:h  Tail: !$:t
echo Head: /usr/bin Tail: id
Head: /usr/bin Tail: id
the 'echo !!2' didn't work for me and from a later post I saw that I think it's supposed to be: 'echo !:2'
add "bind Space:magic-space" to .bashrc and any ! combination will be automatically expanded when you hit space.
+7  A: 
$ touch {1,2}.txt
$ ls [12].txt
1.txt  2.txt
$ rm !:1
rm [12].txt
$ history | tail -10
10007  touch {1,2}.txt
$ !10007
touch {1,2}.txt
$ for f in *.txt; do mv $f ${f/txt/doc}; done
Allan Wind
Use `history 10` instead of `history | tail -10` (which should be `tail -n 10` by the way since that syntax is deprecated).
Dennis Williamson
+1  A: 

And this one is key for me actually:

set -o vi


Allan Wind
+18  A: 

^R reverse search. Hit ^R, type a fragment of a previous command you want to match, and hit ^R until you find the one you want. Then I don't have to remember recently used commands that are still in my history. Not exclusively bash, but also: ^E for end of line, ^A for beginning of line, ^U and ^K to delete before and after the cursor, respectively.

I can never remember ^U for some reason. Isn't there a word delete delete shortcut too?
^W deletes the word before the cursor. (Feel free to edit your answer with this.)
Jon Ericson
^R being so useful that it was mentioned in the question :)
Mark Baker

I've always liked this one. Add this to your /etc/inputrc or ~/.inputrc

"\e[A":history-search-backward "\e[B":history-search-forward

When you type ls <up-arrow> it will be replaced with the last command starting with "ls " or whatever else you put in.

+106  A: 

Renaming/moving files with suffixes quickly:
cp /home/foo/realllylongname.cpp{,-old}

This expands to:
cp /home/foo/realllylongname.cpp /home/foo/realllylongname.cpp-old

Awesome! Now I need to try and remember this one.
Jon Ericson
Just to point out that to do the reverse (going from .cpp-old to .cpp) you'd do cp /home/foo/realllylongname.cpp{-old,}
+10  A: 

pushd and popd almost always come in handy

+7  A: 

Using 'set -o vi' from the command line, or better, in .bashrc, puts you in vi editing mode on the command line. You start in 'insert' mode so you can type and backspace as normal, but if you make a 'large' mistake you can hit the esc key and then use 'b' and 'f' to move around as you do in vi. cw to change a word. Particularly useful after you've brought up a history command that you want to change.

+1  A: 

This prevents less (less is more) from clearing the screen at the end of a file:

export LESS="-X"

I prefer reading man pages in vi, so I have the following in my .profile or .bashrc file

man () {
    /usr/bin/man $sought | col -b | vim -R -c "set nonumber" -c "set syntax=man"  -
There's also this ( which can be set as `$PAGER` :)
+2  A: 

I have various typographical error corrections in aliases

alias mkae=make

alias mroe=less
I see this a lot, but I think it's a mistake. I can't articulate why not, but it seems like it gives the user license to be lax in typing accuracy. Maybe I'm just up-tight. ;-)
Jon Ericson
i guess you won't use the sl command.
zsh can suggest corrections without defining lots of aliases.
+1 to @RamyenHead for [sl](
Dennis Williamson
+3  A: 

Ctrl + L will usually clear the screen. Works from the Bash prompt (obviously) and in GDB, and a lot of other prompts.

+2  A: 

The easiest keystrokes for me for "last argument of the last command" is !$

echo what the heck?

what the heck?

echo !$

Geee, I find editing what the UP cursor presents easier on the brain.
I always forget this one. Now I'll remember it. :)
+7  A: 

String multiple commands together using the && command:

./ && tail -f log.txt


kill -9 1111 && ./
if one fail, the other command wont be executed (fail fast, like in programmation)
Frederic Morin
The opposite is to use the logical or '||' in which the right hand side will only be executed if the left hand side is false. Example: <code>command_1 || command_2</code>
+10  A: 

One preferred way of navigating when I'm using multiple directories in widely separate places in a tree hierarchy is to use (listed below). Once defined, you can do

cd --

to see a list of recent directories, with a numerical menu

cd -2

to go to the second-most recent directory.

Very easy to use, very handy.

Here's the code:

# do "."
# acd_func 1.0.5, 10-nov-2004
# petar marinov, http:/, this is public domain

cd_func ()
  local x2 the_new_dir adir index
  local -i cnt

  if [[ $1 ==  "--" ]]; then
    dirs -v
    return 0

  [[ -z $1 ]] && the_new_dir=$HOME

  if [[ ${the_new_dir:0:1} == '-' ]]; then
    # Extract dir N from dirs
    [[ -z $index ]] && index=1
    adir=$(dirs +$index)
    [[ -z $adir ]] && return 1

  # '~' has to be substituted by ${HOME}
  [[ ${the_new_dir:0:1} == '~' ]] && the_new_dir="${HOME}${the_new_dir:1}"

  # Now change to the new dir and add to the top of the stack
  pushd "${the_new_dir}" > /dev/null
  [[ $? -ne 0 ]] && return 1

  # Trim down everything beyond 11th entry
  popd -n +11 2>/dev/null 1>/dev/null

  # Remove any other occurence of this dir, skipping the top of the stack
  for ((cnt=1; cnt <= 10; cnt++)); do
    x2=$(dirs +${cnt} 2>/dev/null)
    [[ $? -ne 0 ]] && return 0
    [[ ${x2:0:1} == '~' ]] && x2="${HOME}${x2:1}"
    if [[ "${x2}" == "${the_new_dir}" ]]; then
      popd -n +$cnt 2>/dev/null 1>/dev/null

  return 0

alias cd=cd_func

if [[ $BASH_VERSION > "2.05a" ]]; then
  # ctrl+w shows the menu
  bind -x "\"\C-w\":cd_func -- ;"
+1  A: 

When navigating between two separate directories and copying files back and forth, I do this:

cd /some/where/long
cd /other/where/long

cp $src/foo $dest

command completion will work by expanding the variable, so you can use tab completion to specify a file you're working with.
+6  A: 

I've always been partial to:

ctrl-E # move cursor to end of line
ctrl-A # move cursor to beginning of line

I also use shopt -s cdable_vars, then you can create bash variables to common directories. So, for my company's source tree, I create a bunch of variables like:

export Dcentmain="/var/localdata/p4ws/centaur/main/apps/core"

then I can change to that directory by cd Dcentmain.

Drew Frezell
Home and End do the same things as crtl-A and ctrl-E.
This helps on Mac Laptops that don't have home and end keys.
Unfortunately ctrl-A is also the escape key for `screen` by default. I remap it to ctrl-X in my `.screenrc`, but then I'm not an emacs user.
system PAUSE
+1  A: 

<anything> | sort | uniq -c | sort -n

will give you a count of all the different occurrences of <anything>.

Often, awk, sed, or cut help with the parsing of data in <anything>.

+1  A: 

du -a | sort -n | tail -99

to find the big files (or directories of files) to clean up to free up disk space.

+14  A: 

I use the following a lot:

The :p modifier to print a history result. E.g.


Will print the last command so you can check that it's correct before running it again. Just enter !! to execute it.

In a similar vein:


Will search your history for the most recent command that contained the string 'foo' and print it.

If you don't need to print,


does the search and executes it straight away.

Steve Lacey
Instead of using :p, you can also use magic-space:
+1  A: 

$_ (dollar underscore): the last word from the previous command. Similar to !$ except it doesn't put its substitution in your history like !$ does.

Ted Percival
+28  A: 

My favorite command is "ls -thor"

It summons the power of the gods to list the most recently modified files in a conveniently readable format.

Reminds me of another, totally useless but also funny command: `ls -bart -simpson -ruls`.S, ICNR
'ls -tor' is also useful since you can quickly find large files.And also, the original Swedish spelling of the name of the god of thunder is actually 'Tor'.
In Danish you can use `ls -lort` which is the Danish word for "shit". Omitting any groups and not getting the wrath of valhal :)
Jesper Rønn-Jensen
one could also say it like "ls -lotr" which apparently has something to do with Tolkien and Lord Of The Rings :)
+2  A: 

Eliminate duplicate lines from a file

#sort -u filename >

List all lines that do not match a condition

#grep -v ajsk filename

These are not necessarily Bash specific (but hey neither is ls -thor :) )

Some other useful cmds:

prtdiag, psrinfo, prtconf - more info here and here (posts on my blog).

What about `sort -u filename |uniq`?
why would you need "|uniq" ? Sort already does that for you. uniq just remove successive duplicates from the input, and writes the result to the output.
+8  A: 
type -a PROG

in order to find all the places where PROG is available, usually somewhere in ~/bin rather than the one in /usr/bin/PROG that might have been expected.

It will also tell you if it's a function or alias. If it's in multiple places in your `PATH` it will show each of them.
Dennis Williamson
alias mycommand = 'verylongcommand -with -a -lot -of -parameters'
alias grep='grep --color'

find more than one word with grep :

netstat -c |grep 'msn\|skype\|icq'
Actually, using `export GREP_OPTIONS='--color=auto'` is the "correct" way to have a colorized grep.
+60  A: 

My favorite is '^string^string2' which takes the last command, replaces string1 with string2 and executes it

$ ehco foo bar baz
bash: ehco: command not found
$ ^ehco^echo
foo bar baz

Bash command line history guide

This is non-greedy. How do I make it greedy?
The 2nd page of that guide is essential
@andre-r: `!!:gs/ehco/echo/` performs a global search and replace on the last command (confer `!!` in That is not equivalent to `^ehco^echo` which just replaces one instance of "ehco" -- a more accurate response would be `!!:s/ehco/scho`.
+1  A: 

Not really obscure, but one of the features I absolutely love is tab completion.
Really useful when you are navigating trough an entire subtree structure, or when you are using some obscure, or long command!

+1  A: 

A few years ago, I discovered the p* commands or get information about processes: ptree, pgrep, pkill, and pfiles. Of course, the mother of them all is ps, but you need to pipe the output into less, grep and/or awk to make sense of the output under heavy load. top (and variants) help too.

Jon Ericson

You changed to a new directory and want to move a file from the new directory to the old one. In one move: mv file $OLDPWD


If I am searching for something in a directory, but I am not sure of the file, then I just grep the files in the directory by:

find . -exec grep whatIWantToFind {} \;
That's find. What about concentrating on bash features?
Did you know that grep is already capable of recursively entering directories? For example: "grep -Rine 'whatIWantToFind' ." will search all files and subfolders for the string, and output the file and line number that it found them.
@hendry - But find(1) is so useful, and most of the time only in a CLI way.
"time . -exec grep foo {} \;" took 0.928 seconds and "time grep -r foo *" took 0.29s when searching /etc for all occurrences of foo (in this case I let "foo" be my tld).
alias -- ddt='ls -trFld'
dt () { ddt --color "[email protected]" | tail -n 30; }

Gives you the most recent files in the current directory. I use it all the time...

+7  A: 

Similar to many above, my current favorite is the keystroke [alt]. (Alt and "." keys together) this is the same as $! (Inserts the last argument from the previous command) except that it's immediate and for me easier to type. (Just can't be used in scripts)


mkdir -p /tmp/test/blah/oops/something
cd [alt].
Also try combining it with Alt-[0-9] (hit the first combination, then release, then the second). e.g. if last command was 'mv foo bar', then "Alt-0 Alt-." gives 'mv', "Alt-1 Alt-." gives 'foo', "Alt-2 Alt-." and basic Alt-. both give 'bar', etc.
Sam Stokes
Also try pressing Alt-. more than once (or press down Alt, hold it there, press dot many times, and then release Alt) This is similar to pressing Ctrl-R more than once.
+2  A: 

A simple thing to do when you realize you just typed the wrong line is hit Ctrl+C; if you want to keep the line, but need to execute something else first, begin a new line with a back slash - \, then Ctrl+C. The line will remain in your history.

I do Ctrl+A # ENTER when i need to execute something else first.
I do the same Ctrl-A trick, but the backslash Ctrl-C is nice since I don't have to edit the command later to remove the #.
+14  A: 

I often have aliases for vi, ls, etc. but sometimes you want to escape the alias. Just add a back slash to the command in front:


$ alias vi=vim
$ # To escape the alias for vi:
$ \vi # This doesn't open VIM

Cool, isn't it?

+3  A: 

You should be able to paste the following into a bash terminal window.

Display ANSI colour palette:

for f in 0 7 `seq 6`; do
  no="" bo=""
  for b in n 7 0 `seq 6`; do
    co="3$f"; p="  "
    [ $b = n ] || { co="$co;4$b";p=""; }
    no="${no}${e}${co}m   ${p}${co} ${e}0m"
    bo="${bo}${e}1;${co}m ${p}1;${co} ${e}0m"
  echo -e "$no\n$bo"

256 colour demo:

yes "$(seq 232 255;seq 254 -1 233)" |
while read i; do printf "\x1b[48;5;${i}m\n"; sleep .01; done
This is a Bash question. You should use Bash features. `;-)` `for f in 0 7 {1..6}; do` and `while :; do printf "%s\n" {232..255} {254..233} | while read i; do printf "\x1b[48;5;${i}m\n"; sleep .01; done; done`
Dennis Williamson
+1  A: 

Want to get the last few lines of a log file?

tail /var/log/syslog

Want to keep an eye on a log file for when it changes?

tail -f /var/log/syslog

Want to quickly read over a file from the start?

more /var/log/syslog

Want to quickly find if a file contains some text?

grep "find this text" /var/log/syslog
What's wrong with "tail -f /var/log/syslog"? No need to invoke watch here.What's wrong with "more /var/log/syslog"? Skip the cat.and grep "find this text" /var/log/syslog will also save you one step.
Good suggestions. Thanks. (I'm no bash expert!)
+2  A: 

CTRL+D quits the shell.

Vilmantas Baranauskas
I'd never use that! ;-) Actually when I have to log out (once a month or so) that will come in handy. Thanks.
Jon Ericson
Ctrl+D also quits SSH session, Python session, and perl session and so on. What it actually does is like sending "finished!" to stdin of the shell, ssh, python and perl.
@Jon - LOL! I'm the exact same way. I run screen(1) so I'm always logged in (sometimes over SSH too).
I have this in my `~/.bashrc` so I have to press ^D multiple times (three in this case) to prevent accidentally exiting the shell: `export IGNOREEOF="2"`
Dennis Williamson

To be able to quickly edit a shell script you know is in your $PATH (do not try with ls...):

function viscr { vi $(which $*); }

Apropos history -- using cryptic carets, etc. is not entirely intuitive. To print all history items containing a given string:

function histgrep { fc -l -$((HISTSIZE-1)) | egrep "[email protected]" ;}
+1  A: 

The FIGNORE environment variable is nice when you want TAB completion to ignore files or folders with certain suffixes, e.g.:

export FIGNORE="CVS:.svn:~"

Use the IFS environment variable when you want to define an item separator other than space, e.g.:

export IFS="

This will make you able to loop through files and folders with spaces in them without performing any magic, like this:

$ touch "with spaces" withoutspaces
$ for i in `ls *`; do echo $i; done
$ IFS="
$ for i in `ls *`; do echo $i; done
with spaces
Try `IFS=$'\n'`. It's more readable. Also try `for i in *`.
Dennis Williamson
+5  A: 

!<first few characters of the command> will execute the last command which matches.


!b will run "build whatever -O -p -t -i -on" !. will run ./a.out

It works best with long and repetitive commands, like compile, build, execute, etc. It saved me sooo much time when coding and testing.

+1  A: 

Good for making an exact recursive copy/backup of a directory including symlinks (rather than following them or ignoring them like cp):

$ mkdir new_dir
$ cd old_dir
$ tar cf - . | ( cd ../old_dir; tar xf - )

Custom Tab Completion (compgen and complete bash builtins)

Tab Completion is nice, but being able to apply it to more than just filenames is great. I have used it to create custom functions to expand arguments to commands I use all the time. For example, lets say you often need to add the FQDN as an argument to a command (e.g. ping You can use compgen and complete to create a bash function that reads your /etc/hosts file for results so all you have to type then is:

ping blah.<tab>

and it will display all your current match options.

So basically anything that can return a word list can be used as a function.

Install [bash-completion]( It has this `ping` completion and many more.
Dennis Williamson

When running a command with lots of output (like a big "make") I want to not only save the output, but also see it:

make install 2>&1 | tee E.make


As a quick calculator, say to compute a percentage:

$ date
Thu Sep 18 12:55:33 EDT 2008
$ answers=60
$ curl ""  > tmp.html
$ words=`awk '/class="post-text"/ {s = s $0} \
> /<\/div>/ { gsub("<[^>]*>", "", s); print s; s = ""} \
> length(s) > 0 {s = s $0}' tmp.html \
> |  awk '{n = n + NF} END {print n}'`
$ answers=`awk '/([0-9]+) Answers/ {sub("<h2>", "", $1); print $1}' tmp.html`

and finally:

$ echo $words words, $answers answers, $((words / $answers)) words per answer
4126 words, 60 answers, 68 words per answer

Not that division is truncated, not rounded. But often that's good enough for a quick calculation.

+1  A: 

Top 10 commands again (like ctcherry's post, only shorter):

history | awk '{ print $2 }' | sort | uniq -c |sort -rn | head
+1  A: 

I'm new to programming on a mac, and I miss being able to launch gui programs from I have to create functions like this:

function macvim
/Applications/ "[email protected]" -gp &
Why can't you just "open /Applications/"?

I always set my default prompt to "[email protected]:/current/path/name/in/full> "

PS1='\[email protected]\h:\w> '
export PS1

Saves lots of confusion when you're dealing with lots of different machines.

Actually `PS1` works without exporting it. Basically any special variable mentioned in the bash man page only has an effect locally; exporting it is only for making it able to be read from programs bash launches.
while IFS= read -r line; do
echo "$line"
done < somefile.txt

This is a good way to process a file line by line. Clearing IFS is needed to get whitespace characters at the front or end of the line. The "-r" is needed to get all raw characters, including backslashes.

+9  A: 

I have got a secret weapon : shell-fu.

There are thousand of smart tips, cool tricks and efficient recipes that most of the time fit on a single line.

One that I love (but I cheat a bit since I use the fact that Python is installed on most Unix system now) :

alias webshare='python -m SimpleHTTPServer'

Now everytime you type "webshare", the current directory will be available through the port 8000. Really nice when you want to share files with friends on a local network without usb key or remote dir. Streaming video and music will work too.

And of course the classic fork bomb that is completely useless but still a lot of fun :

$ :(){ :|:& };:

Don't try that in a production server...

I guess i shouldn't webshare /
LOL. Could be fun.
I guess you can simplify the command to `python -m SimpleHTTPServer` (unless I'm missing something fancy the original command does
Jesper Rønn-Jensen
Meh. On a production server that fork bomb will just get squelched by the OS; there are limits on the number of processes that any user can create.
Donal Fellows
@Donal: You should try it and report your findings.
Michael Foukarakis
+1  A: 

Some Bash nuggets also here:

+1  A: 

One of my favorites tricks with bash is the "tar pipe". When you have a monstrous quantity of files to copy from one directory to another, doing "cp * /an/other/dir" doesn't work if the number of files is too high and explode the bash globber, so, the tar pipe :

(cd /path/to/source/dir/ ; tar cf - * ) | (cd /path/to/destination/ ; tar xf - )

...and if you have netcat, you can even do the "netcat tar pipe" through the network !!

+1  A: 

Delete everything except important-file:

# shopt -s extglob
# rm -rf !(important-file)

The same in zsh:

# rm -rf *~important-file

Bevore I knew that I had to move the important fiels to an other dictionary, delete everything and move the important back again.

it can be simpler chmod the "important files" then delete everything.
Gregg Lind
+1  A: 

I have a really stupid, but extremely helpful one when navigating deep tree structures. Put this in .bashrc (or similar):

alias cd6="cd ../../../../../.."
alias cd5="cd ../../../../.."
alias cd4="cd ../../../.."
alias cd3="cd ../../.."
alias cd2="cd ../.."
+2  A: 

Using history substiution characters !# to access the current command line, in combination with ^, $, etc.

E.g. move a file out of the way with an "old-" prefix:

mv file-with-long-name-typed-with-tab-completion.txt old-!#^

Florian Jenn
+32  A: 

Sure, you can "diff file1.txt file2.txt", but Bash supports process substitution, which allows you to diff the output of commands.

For example, let's say I want to make sure my script gives me the output I expect. I can just wrap my script in <( ) and feed it to diff to get a quick and dirty unit test:

$ cat
echo -e "one\nthree"
$ ./ 
$ cat expected_output.txt
$ diff <(./ expected_output.txt
> two

As another example, let's say I want to check if two servers have the same list of RPMs installed. Rather than sshing to each server, writing each list of RPMs to separate files, and doing a diff on those files, I can just do the diff from my workstation:

$ diff <(ssh server1 'rpm -qa | sort') <(ssh server2 'rpm -qa | sort')
< kernel-2.6.18-92.1.6.el5
> kernel-2.6.18-92.el5
< libsmi-0.4.5-2.el5
< wireshark-0.99.7-1.el5
< wireshark-gnome-0.99.7-1.el5

There are more examples in the Advanced Bash-Scripting Guide at

Philip Durbin
+1  A: 

On Mac OS X,


will cycle through recent arguments in place. That's: press and release ESC, then press and release . (period key). On Ubuntu, I think it's ALT+..

You can do that more than once, to go back through all your recent arguments. It's kind of like CTRL + R, but for arguments only. It's also much safer than !! or $!, since you see what you're going to get before you actually run the command.

+31  A: 

How to list only subdirectories in the current one ?

ls -d */

It's a simple trick, but you wouldn't know how much time I needed to find that one !

Excellent! All these years the best I could come up with was `alias lsd='ls -F | grep --color /'`, which would list the same thing but in a more lame fashion. However, it would list one dir per line, for ease of parsing. I've modified your command to do the same: `ls -d1 */`
Artem Russakovskii
how does this work? "ls -d" lists just . (which is weird) but "ls -d */" works.
It is a bit tricky..."ls -d" is similar to "ls -d ./" and "ls -d */" to "ls -d ./*/". The '-d' switch set 'ls' tu list only directory entries, but if you give it no parameter, it use the current directory as a parameter, so it has *only* the "." directory to list...
I can't believe I've never discovered this before. Great tip.
Nick Dixon
sudo !!

Runs the last command with administrator privileges.

find -iregex '.*\.py$\|.*\.xml$' | xargs egrep -niH ''  | vi -R -

Searches a pattern in all Python files and all XML files and pipes the result in a readonly Vim session.


Two of my favorites are:

1) Make tab-completion case insensitive (e.g. "cd /home/User " converts your command line to: "cd /home/user" if the latter exists and the former doesn't. You can turn it on with "set completion-ignore-case on" at the prompt, or add it permanently by adding "set completion-ignore-case on" to your .inputrc file.

2) The built-in 'type' command is like "which" but aware of aliases also. For example

$ type cdhome
cdhome is aliased to 'cd ~'
$ type bash
bash is /bin/bash

I like to set a prompt which shows the current directory in the window title of an xterm. It also shows the time and current directory. In addition, if bash wants to report that a background job has finished, it is reported in a different colour using ANSI escape sequences. I use a black-on-light console so my colours may not be right for you if you favour light-on-black.

PROMPT_COMMAND='echo -e "\033]0;${USER}@${HOSTNAME%%.*}:${PWD/#$HOME/~}\007\033[1;31m${PWD/#$HOME/~}\033[1;34m"'
PS1='\[\e[1;31m\]\t \$ \[\e[0m\]'

Make sure you understand how to use \[ and \] correctly in your PS1 string so that bash knows how long your prompt-string actually renders on screen. This is so it can redraw your command-line correctly when you move beyond a single line command.

Adrian Pronk

I want to mention how we can redirect top command output to file using its batch mode (-b)

$ top -b -n 1 > top.out.$(date +%s)

By default, top is invoked using interactive mode in which top runs indefinitely and accepts keypress to redefine how top works.

A post I wrote can be found here

+2  A: 

Using alias can be time-saving

alias myDir = "cd /this/is/a/long/directory; pwd"
+1  A: 

Shell-fu is a place for storing, moderating and propagating command line tips and tricks. A bit like StackOverflow, but solely for shell. You'll find plenty of answers to this question there.

Jean-Marc Liotier
+1  A: 

I'm a big fan of Bash job control, mainly the use of Control-Z and fg, especially if I'm doing development in a terminal. If I've got emacs open and need to compile, deploy, etc. I just Control-Z to suspend emacs, do what I need, and fg to bring it back. This keeps all of the emacs buffers intact and makes things much easier than re-launching whatever I'm doing.

Rob Hruska
+1  A: 

Since I always need the for i in $(ls) statement I made a shortcut:

   if test -z ${2:0:1}; then action=echo; else action=$2; fi
   for i in $(ls $1);
      do $action $i ;

Another one is:

echo ${!B*}

It will print a list of all defined variables that start with 'B'.

+4  A: is also a great site.

I learned quite useful things there like:

sudo !!


mount | column -t
For anyone who's never heard of `!!`, it appends your last command to whatever precedes the `!!` and is super useful. Click here for an example:
+2  A: 

Insert preceding lines final parameter

ALT-. the most useful key combination ever, try it and see, for some reason no one knows about this one.

Press it again and again to select older last parameters.

Great when you want to do something else to something you used just a moment ago.

+4  A: 


This copies to the Mac system clipboard. You can pipe commands to it...try:

pwd | pbcopy

Max Masnick
N.B! This is a Mac specific command.
+1  A: 

alias ..='cd ..'

So when navigating back up a directory just use ..<Enter>

bash 4 solves this with `shopt -s autocd`

How to find which files match text, using find | grep -H In this example, which ruby file contains the jump string -

find . -name '*.rb' -exec grep -H jump {} \;


Mac only. This is simple, but MAN do I wish I had known about this years ago.

open ./

Opens the current directory in Finder. You can also use it to open any file with it's default application. Can also be used for URLs, but only if you prefix the URL with http://, which limits it's utility for opening the occasional random site.

+2  A: 

ctrl-u delete all written stuff


./mylittlealgorithm < input.txt > output.txt

+4  A: 

Duplicate file finder

This will run checksums recursively from the current directory, and give back the filenames of all identical checksum results:

find ./ -type f -print0 | xargs -0 -n1 md5sum | sort -k 1,32 | uniq -w 32 -d --all-repeated=separate | sed -e 's/^[0-9a-f]*\ *//;'

You can, of course, change the path around.
Maybe put it into a function or alias, and pass in the target path as a parameter.

+1  A: 

SSH tunnel:

ssh -fNR 1234:localhost:22 [email protected]
+1  A: 

For the sheer humor factor, create an empty file "myself" and then: $ touch myself

Ken Chen
What about creating an empty file with `$ touch myself`?
+3  A: 

I have plenty of directories which I want to access quickly, CDPATH variable is solution that speed up my work-flow enormously:

export CDPATH=.:/home/gadolin/sth:/home/gadolin/dir1/importantDir

now with cd I can jump to any of sub directories of /home/gadolin/sth or /home/gadolin/dir1/importantDir without providing the full path. And also <tab> works here just like I would be there! So if there are directories /home/gadolin/sth/1 /home/gadolin/sth/2, I type cd 1 wherever, and I am there.

+1 I do that too. The only disadvantage is decreasing tab-completion-smartness, e.g. if `/home/gadolin/sth` has a `imported` directory but I want to cd to `importantFiles` in the current directory I either have to enter i TAB (yields import) a TAB or prepend `./`. But still a great feature IMHO
Tobias Kienzler
Then you may like Autojump:
Alex B
@Tobias you may avoid that by adding "." to CDPATH at the very begging as I do. Thus I decided that dirs in current directory have higher priority.