What are your favorite command line features or tricks?

This expands somewhat on the !! trick mentioned in this answer. There are actually a bunch of history-related commands that tend to get forgotten about (people tend to stab Up 100 times instead looking for a command they know they typed).

• The history command will show a list of recently run commands with an event designator to the left
• !N will substitute the command associated with event designator N
• !-N will substitute the N ^th most recent command; e.g. !-1 will substitute the most recent command, !-2 the second most recent, etc.
• As mentioned in the other answer, !! is shorthand for !-1, to quickly substitute the last command
• !string will substitute the most recent command that begins with string
• !?string? will substitute the most recent command that contains string

Word designators can be added on to a ! history command to modify the results. A colon separates the event and word designators, e.g. !!:0. The event designator !! can be abbreviated to just ! when using a word designator, so !!:0 is equivalent to !:0.

• !:0 will get the command that was executed
• !:1 will get the first argument (and !:2 the second, etc.)
• !:2-3 will get the second and third arguments
• !:^ is another way to get the first argument. !:$ will get the last
• !:* will get all arguments (but not the command)

Modifiers can also be appended to a ! history command, each prefixed by a colon. Any number can be stacked on (e.g. !:t:r:p).

• h -- Line up to the base filename
• t -- Only the base filename
• r -- Line up to the filename extension
• e -- Only the filename extension
• s/search/replacement -- Replace the first occurrence of search with replacement
• gs/search/replacement -- Replace all occurrences of search with replacement

bash -- insert preceding line's 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 more to the argument/file you used just a moment ago.

My favorite is

man 7 ascii 

Simple and so very useful.

 Oct Dec Hex Char Oct Dec Hex Char ──────────────────────────────────────────────────────────────────────── 000 0 00 NUL '\0' (null character) 100 64 40 @ 001 1 01 SOH (start of heading) 101 65 41 A 002 2 02 STX (start of text) 102 66 42 B 003 3 03 ETX (end of text) 103 67 43 C 004 4 04 EOT (end of transmission) 104 68 44 D 005 5 05 ENQ (enquiry) 105 69 45 E 006 6 06 ACK (acknowledge) 106 70 46 F 007 7 07 BEL '\a' (bell) 107 71 47 G 010 8 08 BS '\b' (backspace) 110 72 48 H 011 9 09 HT '\t' (horizontal tab) 111 73 49 I 012 10 0A LF '\n' (new line) 112 74 4A J 013 11 0B VT '\v' (vertical tab) 113 75 4B K 014 12 0C FF '\f' (form feed) 114 76 4C L 015 13 0D CR '\r' (carriage ret) 115 77 4D M 016 14 0E SO (shift out) 116 78 4E N 017 15 0F SI (shift in) 117 79 4F O 020 16 10 DLE (data link escape) 120 80 50 P 021 17 11 DC1 (device control 1) 121 81 51 Q 022 18 12 DC2 (device control 2) 122 82 52 R 023 19 13 DC3 (device control 3) 123 83 53 S 024 20 14 DC4 (device control 4) 124 84 54 T 025 21 15 NAK (negative ack.) 125 85 55 U 026 22 16 SYN (synchronous idle) 126 86 56 V 027 23 17 ETB (end of trans. blk) 127 87 57 W 030 24 18 CAN (cancel) 130 88 58 X 031 25 19 EM (end of medium) 131 89 59 Y 032 26 1A SUB (substitute) 132 90 5A Z 033 27 1B ESC (escape) 133 91 5B [ 034 28 1C FS (file separator) 134 92 5C \ '\\' 035 29 1D GS (group separator) 135 93 5D ] 036 30 1E RS (record separator) 136 94 5E ^ 037 31 1F US (unit separator) 137 95 5F _ 040 32 20 SPACE 140 96 60 ` 041 33 21 ! 141 97 61 a 042 34 22 " 142 98 62 b 043 35 23 # 143 99 63 c 044 36 24 $ 144 100 64 d 045 37 25 % 145 101 65 e 046 38 26 & 146 102 66 f 047 39 27 ' 147 103 67 g 050 40 28 ( 150 104 68 h 051 41 29 ) 151 105 69 i 052 42 2A * 152 106 6A j 053 43 2B + 153 107 6B k 054 44 2C , 154 108 6C l 055 45 2D - 155 109 6D m 056 46 2E . 156 110 6E n 057 47 2F / 157 111 6F o 060 48 30 0 160 112 70 p 061 49 31 1 161 113 71 q 062 50 32 2 162 114 72 r 063 51 33 3 163 115 73 s 064 52 34 4 164 116 74 t 065 53 35 5 165 117 75 u 066 54 36 6 166 118 76 v 067 55 37 7 167 119 77 w 070 56 38 8 170 120 78 x 071 57 39 9 171 121 79 y 072 58 3A : 172 122 7A z 073 59 3B ; 173 123 7B { 074 60 3C < 174 124 7C | 075 61 3D = 175 125 7D } 076 62 3E > 176 126 7E ~ 077 63 3F ? 177 127 7F DEL 

Have a look at this website commandlinefu.com.

You can also have a look at these four articles by Peteris Krumins on his blog

• Top Ten One-Liners from CommandLineFu Explained
• The Next Ten One-Liners from CommandLineFu Explained
• Another Ten One-Liners from CommandLineFu Explained
• Yet Another Ten One-Liners from CommandLineFu Explained

Execute last command as root:

sudo !! 

Not sure if this counts as a "trick", but people seem very unaware of the standard readline hotkeys. Of particular use in shells:

• Ctrl+U - Cut the current line
• Ctrl+Y - Paste a line cut with Ctrl+U
• Ctrl+L - Clear the screen and redraw the current line
• Ctrl+G - Get a new line and abandon the current one

CTRL+R in BASH for searching/activating previously executed commands (the contents of ~/.bash_history).

This is often extremely helpful. Running this alias will serve the PWD up over HTTP (indexed) on port 8000:

alias webserver="python -m SimpleHTTPServer" 

And because I run make all the time, and spaz out and type too quickly, these aliases are probably my most used (seriously):

alias maek=make alias mkae=make alias meak=make alias amka=make alias akme=make 

And probably my most frequently used piece of BASH is a simple script I call upload. I use it to blit any kind of content to my Linode, and it copies the resulting HTTP URL to my clipboard (middle click). Very useful for pasting stuff to people in IRC:

scp -r $* $user@$host:public_html && { URL="http://$host/~$user/$(basename $1)" echo "$URL" xselection -replace PRIMARY "$URL" } 

Just a couple. I can post much more later, must get back to work!

diff the output of two commands without creating a temporary file manually (bash):

diff <(ls dir1) <(ls dir2) 

Pretty basic, but people don't seem to know, returns you to the previous dir:

cd - 

Brace Expansion:

Brace expansion is a mechanism by which arbitrary strings may be generated.

It allows you to replace tedious lines like:

mv loong/and/complex/file/name loong/and/complex/file/name.bacukup 

with a shorter instance

mv loong/and/complex/file/name{,backup} 

some other uses

# to display the diff between /etc/rc.conf and /etc/rc.conf.pacsave diff /etc/rc.conf{,.pacsave} # to list files in both /usr/share and /usr/local/share ls /usr/{,local}/share 

Arithmetic Expansion:

Arithmetic expansion allows the evaluation of an arithmetic expression and the substitution of the result. The format for arithmetic expansion is:

$((expression)) 

The expression is treated as if it were within double quotes, but a double quote inside the parentheses is not treated specially. All tokens in the expression undergo parameter expansion, string expansion, command substitution, and quote removal. Arithmetic expansions may be nested.

$ a=1 $ b=2 $ echo $(( a+(b*2) )) 5 

This is usually in my startup script (.bashrc, .profile, whatever)

shopt goodness, check the comments:

shopt -s cdspell # try to correct typos in path shopt -s dotglob # include dotfiles in path expansion shopt -s hostcomplete # try to autocomplete hostnames 

An alias that save keystrokes: mkdir and cd into it:

mkcd () { mkdir -p "$@" && cd "$@"; } 

And last but not least, I've given up on memorizing tar syntax, so:

extract () { if [ -f $1 ] ; then case $1 in *.tar.bz2) tar xjf $1 ;; *.tar.gz) tar xzf $1 ;; *.bz2) bunzip2 $1 ;; *.rar) rar x $1 ;; *.gz) gunzip $1 ;; *.tar) tar xf $1 ;; *.tbz2) tar xjf $1 ;; *.tgz) tar xzf $1 ;; *.zip) unzip $1 ;; *.Z) uncompress $1 ;; *) echo "'$1' cannot be extracted via extract()" ;; esac else echo "'$1' is not a valid file" fi } 

Two bash functions which save me many key strokes.

Do automatically an ls after every successfull cd:

function cd { builtin cd "$@" && ls } 

Go up n levels:

# Usage .. [n] function .. (){ local arg=${1:-1}; local dir="" while [ $arg -gt 0 ]; do dir="../$dir" arg=$(($arg - 1)); done cd $dir #>&/dev/null } 

Since I'm usually halfway into a command line before wanting to search (CTRL-R in bash) I have the following in my .bashrc

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

This means that if I type cd then press up/down I can see all the options that I have cd'd to. Basically I use this for often used dirs. Like "cd w" and I'm ending up going through all the workspaces I use lots.

One thing that saves me a lot of time is the pushd/popd commands. These guys let you create a stack of directories and reduce typing a lot:

/foobar/ > pushd /src/whatever/foo/test /foobar/src/whatever/foo/test > make run /foobar/src/whatever/foo/test > popd /foobar/ > make 

The screen command. It basically saves your command line session for when you come back. It's sort of a terminal manager, like a window manager. That way, in a single terminal session, you can have multiple virtual terminals going on. It's very cool.

If one uses screen, this shell function (put it into .bashrc) is extremely useful:

function scr { if screen -ls | grep -q Main; then # reattach to Main: screen -xr Main else # name session "Main": screen -S Main fi } 

upon typing scr, it will check if your main session exists and will attach to it. Otherwise it will create it.

If you need to edit a particularly long command line in bash

^X^E (Ctrl-X Ctrl-E) 

will open it in the editor ($EDITOR).

In zsh you can get the same behaviour by adding this to .zshrc:

autoload edit-command-line zle -N edit-command-line bindkey '^X^e' edit-command-line 

If you are a fast typist, these come in handy:

alias grpe='grep --color=tty' alias gpre='grep --color=tty' alias rgep='grep --color=tty' alias gerp='grep --color=tty' 

This macro helps you compute totals of a column of output: file sizes, bytes, packets, all you have to do is specify the column that you want to add:

total () { if [ x$1 = x ]; then set `echo 1`; fi awk "{total += \$$1} END {print total}" } 

You use it like this for example, with no arguments, it adds the total of the first column:

du | total 

If you provide the argument, it will sum that column, for example, this gives you the total number of bytes used by all the C# files in /tmp:

ls -l /tmp/*cs | total 5 

Sometimes your console gets messed up because you accidentally viewed a binary file (cat /bin/ls for example), you can restore the terminal with this shell function:

restaura () { perl -e 'print "\e)B";' } 

I like my ls to use characters to distinguish the class of files, and also to hide the backup files generated by my editor (backup files end with the ~ character):

alias ls='ls -FB' 

alias s='sudo' alias r='rake' # i'm a ruby developer alias ..='cd ..' # although with autocd feature for zsh this comes packed. 

One of my favorites when I forget s:

$ s !! # last command with super user priviledges 

If a command takes stdin input, you can read the input from a file with <filename. This can appear anywhere in the command, so these lines are equivalent:

cat filename cat <filename <filename cat 

This is particularly useful for grep, as it allows you to place the expression at the end of the line, so you can quickly modify a grep command it by hitting Up, without needing to scroll left to get past the filename:

<filename grep 'expression' 

You can use CDPATH to set up the directory equivalent of PATH; if you try to cd foo and there is no foo in the current directory, the shell will check each of the directories in CDPATH looking for foo in them, and switch to the first one it finds:

export CDPATH="/usr" cd bin # switches to 'bin' if there is one in the current directory, or /usr/bin otherwise 

vi `which scriptname` 

For when you don't know where something lives, and you don't care either.

The ampersand. It puts your command in the background, so you can continue typing.

$> sudo updatedb & 

Working along, and after a while you see:

[1] 17403 

And your process is done! Great for things where you don't need to wait for them to terminate.

Tab completion. How bad would it suck if you had to type out all the characters of every path?

Umount last mounted device:

mount /media/whatever ... u!mo 

!mo expands to the last command that started with mo (at least in bash). Sometimes one does mv in the middle, so u!m won't work as often.

I have this in my .bashrc

#shortcut for CTRL+C and CTRL+V alias c-c='xclip -sel clip' alias c-v='xclip -o -sel clip' 

function find-all() { python -c "import re import sys for i in re.findall('$1', sys.stdin.read()): if type(i) == type(''): print i else: print i[0]" } 

And when I have html source code in clipboard and want to find all links I use

c-v | find-all 'href="([^"]*)"' | c-c 

And I have all urls in clipboard

I also have this function

function lsq(){ ls -lh $@ | tr -s ' ' | cut -d' ' -f5,8 } 

which display size (human readable) and filename.

alias temp='cat /proc/acpi/thermal_zone/THRM/temperature' 

this alias is for show temerature

function separate() { python -c "import sys,re; print '$1'.join(re.split('\s*', sys.stdin.read().strip()))"; } 

with this function I can calculate product or sum of arguments.

alias sum='separate + | bc' alias product='separate * | bc' function split-join() { python -c "import sys,re; print '$2'.join(re.split('$1', sys.stdin.read().strip()))"; } 

This is usefull function which split standard input separated by regex and then join the result.

function factorial() { seq -s* $1 | bc } 

factorial function

function wiki() { dig +short txt $1.wp.dg.cx; } 

This function display wiki text over DNS

I also have three color funcions

function blue() { echo -e "\x1b[34m\x1b[1m"$@"\x1b[0m"; } function green() { echo -e "\x1b[32m\x1b[1m"$@"\x1b[0m"; } function red() { echo -e "\x1b[31m\x1b[1m"$@"\x1b[0m"; } 

function md5check() { test `md5sum $2 | cut -d' ' -f1` = "$1" && green [OK] || red [FAIL] } 

This function validate file md5 hash.

this will show error message for a given code

function strerror() { python -c "import os; print os.strerror($1)"; } 

You can print all messages with

alias all-errors='for i in `seq 131`; do echo -n "$i: "; strerror $i; done' 

Another useful ZSH trick:

Treat the output of a command as a file:

emacs =(hg cat -r 100 somefile) 

This opens an old version of a Mercurial-tracked file in emacs for syntax-highlighted viewing. Without that, I would have to mess around with hg revert, hg archive, or explicitly send hg cat output to a temporary file.

Of course, this works with any program that opens files, and any program that prints to standard output.

A ZSH-specific feature is suffix aliases, set by giving alias the -s flag:

alias -s ext=program 

If a given extension has a suffix alias, you can execute a file with that extention directly, and ZSH will launch the given program and pass the filename as an argument. So if the above alias is in effect, these lines are equivalent:

/path/to/foo.ext program /path/to/foo.ext 

One of my all-time favorite ZSH features is named directories. You can export a variable with a given name, with a value that points to a certain path:

export foo=/usr/bin 

Now you can use ~foo in a command to refer to /usr/bin:

cd ~foo ~foo/ls cat ~foo/filename 

See this question.

When you run ps ax | grep string:

[steve@sage-arch ~]$ ps ax | grep 'openbox' 3363 ? Ss 0:00 /usr/bin/openbox 3382 ? Ss 0:00 /usr/bin/ssh-agent -- /usr/bin/openbox-session 3386 ? S 0:00 /bin/sh /usr/bin/openbox-session 3388 ? S 0:00 /bin/sh /usr/bin/openbox-session 3389 ? S 0:00 /bin/sh /usr/bin/openbox-session 3390 ? S 0:00 /bin/sh /usr/bin/openbox-session 5100 pts/0 S+ 0:00 grep openbox 

the last line containing grep is somethings a bit anoying

You can rid yourself of this by running ps ax | grep '[s]tring':

[steve@sage-arch ~]$ ps ax | grep '[o]penbox' 3363 ? Ss 0:00 /usr/bin/openbox 3382 ? Ss 0:00 /usr/bin/ssh-agent -- /usr/bin/openbox-session 3386 ? S 0:00 /bin/sh /usr/bin/openbox-session 3388 ? S 0:00 /bin/sh /usr/bin/openbox-session 3389 ? S 0:00 /bin/sh /usr/bin/openbox-session 3390 ? S 0:00 /bin/sh /usr/bin/openbox-session 

update: or just run pgrep string

• The do-nothing command : as in

  while :; do :; done 

• Brace expansion in combination with for loops:

  for c in {1..3}; do :; done 

• ! operator and short circuiting operators || and &&

  [ -d /tmp/dir ] || mkdir /tmp/dir if ! ping 34.41.34.1; then :; fi 

• using sub shells instead of pop/push (comes in handy in scripts)

  ~$ ( cd /tmp; echo $PWD ) /tmp ~$ 

• the kind-of what-is command type

  ~$ type type type is a shell builtin ~$ type ls ls is aliased to `ls --color=auto' ~$ f(){ :; } ~$ type f f is a function f () { : } 

• also very nice: here-strings

  ~$ cat <<<"here $PWD" here /home/yourname ~$ 

• and my favorite: redirection on a list of commands

  { w; ps; ls /tmp; } 2>/dev/null |less 

I love chucking as much stuff as I can into my PS1. Some useful things to remember:

\e[s and \e[u save and unsave the cursor position respectively. I use this to create an 'info-bar' at the top of the screen, a couple of lines long, which can fit more stuff. Example:

PS1='\[\e[s\e[7m\e[1;1H\]\w\n\t \j / \! / \#\[\e[u\e[0m\e[33;1m\][\u@\h \[\e[34m\]\W]\[\e[0m\]\$ ' 

Combine with alias clear='echo -e "\e[2J\n"'. Try it out!

Also, the PROMPT_COMMAND variable defines a command to execute before the PS1 every time.

Another one is the bg command. If you forget to put & at the end of a command, just press ^Z and type bg, and it runs in the background.