Debian Administration

my favorite obscure bash trick is control-r.

On a blank command line, hit control-r to do a "reverse incremental search". As you type, bash will search your command history and auto-fill the most recent command that matches the pattern you type in. Hit control-r again to go back to the next most recent match. I use this one all the time. :)

--Nato

I find very useful simple aliases inserted in .profile, .bashrc or wathever be the file you use to adapt your environment.

They are mainly to find things into long outputs from certain commands.

My conventions is repeating the last letter of the long output command. The examples will clarify things inmediatly
-To see something coming into ls output: lss
alias lss='ls -lrt | grep $1'

-To check a process is running in a box with a heavy load: pss
alias pss='ps -ef | grep $1'

-To check the existence of an environment variable: envv
alias envv='env | grep $1'

-To see if a package or packages are installed in the system: dpkgg
alias dpkgg='dpkg -l | grep $1'

etc.

This may admit lots of modifications to make these aliases fit better your needs, like, including more arguments ( $2, $3, etc), or piping more commands to suit some long operation that one perform frequently, etc

So, to use them you simply type

lss something
pss process, or process number, or process parent or any data you now it comes in the process line output
envv variable
etc.

Hope this helps.
Fernando

Hi, my tip is for determinate the size of each directory (and files) and help me to know what is the bigger:

du -kx ./ | sort -n

Isn't a really bash tip, but it help me in my work ;)

my 2 cents

Marco Bertorello <marco(at)bertorello(dot)ns0(dot).it

Here's a useful little bashism if you are into non-portable shell scripting.

usage () {
        echo "usage: ${0##*/} "
        exit 1
}

The use of

${0##*/}

prevents one from having to shellout to basename(1).

pushd and popd can be useful when you're in a very deep patch tree and need to quickly do something somewhere else, and unlike cd - remains in place no matter how many directories you browse through:

sam@io:/usr/a/very/long/and/annoying/to/type/path$ pushd /etc/apache


/etc/apache /usr/a/very/long/and/annoying/to/type/path


sam@io:/etc/apache$ cd ssl


#Some more stuff here


sam@io:/etc/apache/ssl$ popd


/usr/a/very/long/and/annoying/to/type/path


sam@io:/usr/a/very/long/and/annoying/to/type/path$ 

^a and ^e (beginning of line and end of line) and ^w (delete word) are incredibly useful too.

I like to use $_ to access the last variable from the previous command.

keith@fugit:/tmp$ ls -la foo
-rw-r--r-- 1 keith keith 20 Apr 29 13:21 foo
keith@fugit:/tmp$ cat $_
This is some text.
keith@fugit:/tmp$

you can with easily replace occurance of word1 with word2 in last command with ^word1^word2 here is example:

bilke@hydrogen:~$ ls /var
account  cache  local  log         mail  run    tmp  yp
backups  lib    lock   lost+found  opt   spool  www

bilke@hydrogen:~$ ^var^home
ls /home
bilke  export  ftp  igor  joejoe  lost+found  mirjam  pivo  samba

bilke@hydrogen:~$

best regards, bilke

On the whole I love bash_completion, but...

It's possible that this is only (or mostly) a problem with old, stable (Woody), which, yes, I still use on a number of machines where continuing to just work is more important than newer versions of things. All those servers in closets that might or might not even have monitors if an upgrade should go awry...

Anyway, with the fancy scripted completion turned on, I find that tab completion's leading side effect works less well, or sometimes not at all. That's hitting tab (twice) to see what all is in a directory. Very handy for context when groping for an obscure config file you haven't had to look at in a couple years, let me tell you. The failures seem to be erratic, aside from obvious things like only getting directories when the command is cd and so forth. On the whole the smarter tab completion seems well worth it, but there may be a few disruptions if you're already accustomed to using tab completion. - MartinManey

I found very useful CTRL + l (it clears the screen)

I like to set some shopt options in my .bashrc, particularly
shopt -s extglob
Then I can for example cd into a directory full of mp3s, and find any file that isnt an mp3..

ls -lh !(*.mp3)

To change to the previous directory just run:

cd -


Along the same lines, you can refer to the previous PWD as "~-" for example:

cd /etc/ ; cd /tmp ; cp ~-/passwd . ; will copy /etc/passwd to /tmp/passwd

Commandlines not appearing in the history file:

Well, I,m not sure if this one is really necessary - except in cases, when you are forced to write sensitive data as an option in a command like passwords *shudder* - but it may be good to know, that there are environment variables, with which you can control the behaviour of saving commands to the history file: one way is to set

$ HISTCONTROL=ignorespace

Afterwards you can type commands beginning with a space, that will not show up in your history file.

$ ll
.... lot of files
$ _ls -a
.... again lot of files
[UP]
$ ll

Many more things are possible. Just "man bash" and "/HISTCONTROL".

Best regards and thanks for hints of many I didn't know ;-))

For years I was a bash fan, and used autocompletion a lot. But now I've converted to zsh(1). zsh autocompletion doesn't seem to be such a hack to me, and I perceive it as quicker. And zsh has much better meta-chars. For example ls **/*.c will list all c files in all subdirectories of the current one, *recursively*. Much nicer than find . -name '*.c' -ls.
(BTW I am comparing to bash 2.05; maybe bash 3 is better.)

Will

A features I use frequently is Alt-T, that switches the word under the cursor with the previus one. Ex: with the cursor over 'that', "this that"+Alt-T becomes "that this".

And another one a use very frequently is brace expansion. Ex: "echo a{1,2,3}" prints "a1 a2 a3" on the screen. Very useful for: "mv /a/very/long/pathname{,.OLD}"

You wrote:
[...]
To cause your shell to use it run the following command, then login again:
echo '. /etc/bash_completion' >> ~/.bashrc
[...]

Do you actually have a reason to login again after editing your .bashrc?
You don't have to, just use the same command as you just added to your .bashrc, but now with your just edited .bashrc.
Just run:
. .bashrc
And .bashrc is executed in your current shell instead of in a subshell.

my 2 cents,
Nok

I'm ssh'ing and scp'ing a lot, so I define my prompt to be
'[\u@\h:\w]$ '. This makes it much easier to copy/paste user@host:/path to other shell windows.

In order to keep all bash configuration in sync on many hosts my .bashrc sources a couple of files that are kept in cvs. One of those files is a 'cvs update' :-)

my .inputrc:
set completion-ignore-case On #tab complete without needing to get the case right
set show-all-if-ambiguous On #show list on first tab, no need to hit tab again
set visible-stats On # not sure what this one does...
set mark-symlinked-directories On # handy

Now, some functions from my .bashrc:

These are just nice shortcuts for searching for a string in filenames under the current directory
findme() { find -iname "*$@*" -or -iname ".*$@*"; }
findmewhole() { find -iwholename "*$@*" -or -iwholename ".*$@*"; }

This takes a string and provides a top-like display of matching lines from ps. The 'grep -v grep' bit is because otherwise the 'grep -i $@' line matches itself!
running() { watch -n1 "ps aux | grep -i $@ | grep -v grep"; }

iain

It doesn't look like there are too many of us 'vi' mode users based on the responses I saw.

But, if you do use the VI edit mode (set -o vi) be aware that you cannot use the 'ESC-...' stuff mentioned here for EMACS mode.

For example, the 'ESC-.' that fills in the last arg from the prior command for EMACS mode, will repeat the last edit if in VI mode. So:

cp[ESC-.]

produces:

cpcp

Which is probably not too useful ;)

Bob

Imagine a shell script with some compiler call like

gcc -O99 -march=formula1 and-some-more-things

and you want to strip away the -O99 option remembering what was there:

gcc $(# -O99 ) -march=formula1 and-some-more-things

I frequently use Bash's brace expansion for preparation of quick-fix patches, or preparation of fixed diffs that correct patch failures.

Example:
# Make a backup of xterm.c.
$ cp xterm.c{,~}
# Patch it.
$ patch -p0 </tmp/xterm_patch.diff
# Get warned about offsets, fuzz, and rejected hunks.
# Use vim to hand-merge rejected hunks.
$ vim -O xterm.c{,.rej}
# Create new diff that applies cleanly.
$ diff -u xterm.c{~,} >/tmp/good_xterm_patch.diff

I have found that simple use of brace-expansion like this saves me a lot of typing. Even tab-completion can get tedious if you're operating on things deep within a directory structure, and for whatever reason don't want to cd in there. (Think xc/programs/Xserver/hw/xfree86/drivers/ati/radeon_driver.c.)

--Branden Robinson

A few months back I blogged about how I perform mass file actions in bash (i.e. how to execute a sequence of commands on multiple files). It's not rocket science, but is a pattern I use frequently and is useful for beginners to know.

The complete list of bash completed applications can be found here: http://www.hypexr.org/bash_tutorial.shtml#completion

very useful in any situation :)

CTRL + SHIFT + _ UNDO

If you need to do something to a lot of files or directories you can use:
for fileordir in `ls /some/dir`;
do
somecommand $fileordir;
someothercommand $fileordir;
done

Use ctrl+z to stop a running process and bg to start in in the background.

Use ctrl+u to cut left, ctrl+k to cut right, and ctrl+y to insert the cutted text/command.

some nice variables:
$RANDOM contains a random number. Really useful for creating tempfiles in bash scripts

$? contains exit status of last process executed.

The while loop is nice if you need to check the status of something and do something if the status change.

Test commands list -z $SOMEVAR to see if $SOMEVAR is an empty string or undefined.

--Simon Østengaard

All that comments about Ctrl-key make something is because bash behaves like emacs and some commands have similar functions. In fact, bash has 2 modes of operation, the emacs mode (default) and the vi mode (i have never used that). This is a list of commands in the emacs mode that i remember:

Ctrl-a -> go to the start of command line
Ctrl-e -> go to the end of command line
Ctrl-p -> previous command in history
Ctrl-n -> next command in history
Ctrl-f -> next character in command line
Ctrl-b -> previous character in command line
Ctrl-r -> reverse search in history file
Ctrl-d -> delete current character
Ctrl-k -> delete from the prompt to the end of command line
Ctrl-_ -> undo (yes, but limited)
Meta-< -> go to beginning of history file
Meta-> -> go to end of history file
Meta-f -> go to next word in command line
Meta-b -> go to previous word in command line
Meta-d -> delete next word in command line (from the actual position of the prompt)


and that's all i can remember. There is a lot more, you can find that in books about bash (oreilly i think).

Enjoy! ;-)

Handy little trick for vim and bash.

To open the last file you edited, just alias:

alias lvim="vim -c \"normal '0\""

To search forward for a specific character
ctrl-] character
To seach backward
esc ctrl-] character

Anyone know how to repeat the search..

I'm particularly fond of bash's ability to do net-redirections (which is purely dependant on the distribution your using as some distros enable it by default, while most don't, hence you'll have to recompile bash using the --enable-net-redirections flag, see documentation).

I wanted BASH to keep a list of all the directories I visited so that
I could jump to any visited directory by providing a few characters from its name or even go back and forth through the list of visited directories.

Now, BASH already provides a few things that I could use:

1) I could use CDPATH environment variable
If I put in my .bashrc someting like

export CDPATH="/path/dir:/path/dir2"

Next time I do 'cd blah' BASH will check /path/dir and /path/dir2 to see if any of their sudirectories is 'blah'. But every time I create a new directory that has subdirectories of my interest I need to update CDPATH and restart my terminal. Not to mention that NOT all subdirectories will be of my interest so if I have a few 'bin' sudirectories, and I do 'cd bin' BASH will go to the first one found. CDPATH is useful but it's quite annoying if it sends you to the wrong directory.

2)'cd -' can take you to the previously visited directory. But I want more than that. I want to be able to go through the entire history of visited directories.

*) If you know of any other method that pertains to my problem, let me know.

MY SOLUTION

Well, it took me some time but I figured out how to do it.
First I needed to use BASH lists (BASH Arrays).

Arrays are declared like this:

arr=(zero one two three four)
echo ${arr[0]} # gives zero
echo ${arr[@]} # lists entire array as one string
echo ${#arr} # gives the number of elements in an array

Of course, you can combine it with a different input.

arr=(`ls`) # grabs the output of 'ls' into an array
arr=(`cat myfile`) # grabs the file into an array
# every line from the file is assigned to one array element

Little tangent on delimiters
-----------------------------
Strings from `cat myfile` are delimited based on \n (new line)
that is why our 'arr' takes one whole line per element.
If you want your strings to be delimited in some other way,
use IFS="/", where '/' will become a delimiter

If you put in your .bashrc
IFS="
"
then the newline \n will become a delimiter again
(This business with IFS could be a pain.)
-----------------------------

I also needed to do some arithmetic in here, for which I used the
double parentheses expression: (( math ))

m="1" # always use "", even for numbers
((m++)) #increments m
((m--)) #decrements m
((n=m+3))
echo "m=$m n=$n" #gives m=1 n=4

Before the code: How to Use it
-------------------------------
This is how you can use my code below.
You need to put it in .bashrc and restart the terminal.
Suppose you have some directories:
MyDocuments, Test, CodeOfMyProject and its subdir "Two words".

cd MyDocuments # now the history has remembered MyDocuments
cd # You go back to ~
cd Test # Test is also remembered
# And so on for every directory you visit
......

dir save # saves the history into .dir_history in your home directory
# Now every time you open a terminal this history will be loaded
# so you don't have to type it again

cd Two # Sends you to CodeOfMyProject/Two words
cd .. # Sends you to CodeOfMyProject
cd # Sends you home ~
cd - # Sends you backwards in history to CodeOfMyProject
cd - # Sends you backwards again to CodeOfMyProject/Two words
cd + # Sends you forwards in history
cd T # Sends you to Test
# NOTE: all forward history is now deleted
think of it the way web browsers behave!
dir load # loads the history (if you don't want it to load automatically)
cd My # Sends you to MyDocuments

ANOTHER NOTE: If you want to use a regular 'cd' command type \cd
The same thing applies to \dir

c # The alias 'c' will allow you to choose a dir from a list
dir choose # Does the same thing as 'c'

dir clear # clears history

THIRD NOTE: I made the search case sensitive. You can make it insensitive by adding an -i option in 'grep -E $regexp'

FINAL NOTE: If you have too many directories in history the search might become slow. I guess I will add some upper limit on how many directories you can have in history. Also, the history will NOT save itself. You have to do 'dir save'.
You can also put 'dir save' in .bash_logout

NOW THE CODE:
--------------

# put this in your .bashrc to see how it works
# I tried to make useful comments
# but you are welcome to delete them


# -----SECTION: Moving through directories --------

# declaring variables
export dirarr dircnt dirarr_fhist dircnt_fhist

# dirarr is where I keep visited directories (no duplicates)
# dircnt is its length, ${#arr} was giving me some trouble
# dirarr_fhist a an array of forward history

if [ -z $dircnt ]
then dircnt="1"
dirarr=("`pwd`")
fi

if [ -z $dircnt_fhist ]
then
dircnt_fhist="0"
dirarr_fhist=
fi

# some aliases that will save us the trouble of too much typing
alias cd='push'
alias p='push'
alias o='pop'
alias c='choose'
alias dir='dir_utility'

# loads and saves history,
# lists and chooses directories
dir_utility() {

case "$@" in

s|sa|sav|save)
save_dirhist
;;
lo|loa|load)
load_dirhist
;;
l|li|lis|list)
dirl
;;
c|ch|cho|choo|choos|choose)
choose
;;
*)
\dir "$@"
;;
esac
}

# Used by push() function (see below)
pop() {
popd "$@" > /dev/null
}

# This is where 'cd' command is parsed
push(){

case "$@" in
"")
pushd ~ > /dev/null
;;

"-") # going backward in history
prevdir="`pwd`"
popd > /dev/null
dirarr_fhist[$dircnt_fhist]=$prevdir
((dircnt_fhist++))
;;

"+") # going forwards in history
if [ "$dircnt_fhist" == "0" ]
then
echo "Forward list empty"
return 1
fi
((dircnt_fhist--))
dir=${dirarr_fhist[$dircnt_fhist]}
if [ ! -z $dir ]
then
pushd "$dir" > /dev/null
fi
;;

*) # parsing cd
if [ -a "$@" ]
then
pushd "$@" > /dev/null
clear_fhist
curdir="`pwd`"
for ((i=0; $i < $dircnt; i++)); do
if [ "${dirarr[$i]}" == "$curdir" ] ; then
return
fi
done
dirarr[$dircnt]="$curdir"
dircnt=$((++dircnt))
else
cdpartial "$@"
fi

;;
esac

export dirarr dircnt
export dirarr_fhist dircnt_fhist

}

# list history
dirl() {
for ((i=0; $i < $dircnt; i++))
do
if [ "$1" == "-n" ] ; then
echo -e "${dirarr[$i]}\n"
else
echo "${dirarr[$i]}"
fi
done
}

# choose a directory from history
choose() {

if [ ! -z "$1" ] ; then
if (( $1 >= 1 && $1 <= $dircnt )) ; then
num=$1
((num--))
pushd "${dirarr[$num]}" > /dev/null
clear_fhist
return 0
fi
fi


# make IFS take \n as a separator
IFS="
"
PS3="jump to directory # "
select dir_ans in `dirl -n`
do
if [ ! -z $dir_ans ]
then
pushd "$dir_ans" > /dev/null
clear_fhist
break
fi
done
}

# save history
save_dirhist() {
dirl | sort > ~/.dirhistory
}

#load history
load_dirhist() {
# this should go to .bash_login
if [ -r ~/.dirhistory ]; then
# TODO Test validity of directories
#cat .dirhistory | while read line
#do
# echo $line
#done
IFS="
"
dirarr=(`cat ~/.dirhistory`)
#dircnt=${#dirarr} #NOT WORKING
dircnt="`cat ~/.dirhistory|wc -l`"
fi
}

# find a directory in History based on a partial string
cdpartial() {
if [ $dircnt -eq 0 ]
then return
fi

for ((i=0; $i < $dircnt; i++))
do
regexp="$@[^/]*$"
if [ `echo ${dirarr[$i]}| grep -E $regexp | wc -l` -gt 0 ]
then
\cd ${dirarr[$i]}
clear_fhist
return
fi
done
echo "$@: directory not found"
}

# clears forward history
clear_fhist() {
export dirarr_fhist=
export dircnt_fhist="0"
}

# clears history
clear_hist() {
export dirarr=
export dircnt="0"
}

# loads history in .bashrc
load_dirhist

# -----END SECTION: Moving through directories --------

# P.S. I'm using the newest BASH - 3.x

I maintain a short page of bash tips here. Compare, for example, my cd setup with the comment above.

I find CTRL+Z and fg quite handy. An example:

~$ some-big-heavy-long-running-cmd
CTRL+Z

~$ do-something-else
....

~$ fg
results of some-big-heavy-long-running-cmd

ls -Alah
and
grep -Hirn string *