Quick directory navigation in the bash shell

Question

I would like to frequently switch between directories that are in totally unrelated paths, for example /Project/Warnest/docs/ and ~/Dropbox/Projects/ds/test/.

But I don't want to type cd /[full-path]/ all the time. Are there any shortcut commands to switch to previously worked directories?

One solution I could think of is to add environment variables to my bash .profile for the frequently used directories and cd to them using those variables.

But is there any other solution to this?

Answer 1

If you're just switching between two directories, you can use cd - to go back and forth.

Answer 2

There is a shell variable CDPATH in bash and ksh and cdpath in zsh:

CDPATH    The search path for the cd command. This is a colon-separated
          list of directories in which the shell looks for destination
          directories specified by the cd command.

So you can set in your ~/.bashrc:

export CDPATH=/Project/Warnest:~/Dropbox/Projects/ds

Then cd docs and cd test will take you to the first found such directory. (I mean, even if a directory with the same name will exist in the current directory, CDPATH will still be consulted. If CDPATH will contain more directories having subdirectories with the given name, the first one will be used.)

Answer 3

Something else you might try is a tool called autojump. It keeps a database of calls to it's alias (j by default) and attempts to make intelligent decisions about where you want to go. For example if you frequently type:

j ~/Pictures

You can use the following to get there in a pinch:

j Pic

It is available of Debian and Ubuntu, and included on a per-user basis in ~/.bashrc or ~/.zshrc by default.

Answer 4

If it's a small number of directories, you can use pushd to rotate between them:

# starting point
$ pwd
/Project/Warnest/docs
# add second dir and change to it
$ pushd ~/Dropbox/Projects/ds/test
~/Dropbox/Projects/ds/test /Project/Warnest/docs
# prove we're in the right place
$ pwd
~/Dropbox/Projects/ds/test
# swap directories
$ pushd
/Project/Warnest/docs ~/Dropbox/Projects/ds/test

unlike cd -, you can use this with more than two directories

---

Following up on Noach's suggestion, I'm now using this:

function pd()
{
    if [[ $# -ge 1 ]];
    then
        choice="$1"
    else
        dirs -v
        echo -n "? "
        read choice
    fi
    if [[ -n $choice ]];
    then
        declare -i cnum="$choice"
        if [[ $cnum != $choice ]];
        then #choice is not numeric
            choice=$(dirs -v | grep $choice | tail -1 | awk '{print $1}')
            cnum="$choice"
            if [[ -z $choice || $cnum != $choice ]];
            then
                echo "$choice not found"
                return
            fi
        fi
        choice="+$choice"
    fi
    pushd $choice
}

example usage:

# same as pushd +1
$ pd 1

# show a prompt, choose by number
$ pd
 0 ~/Dropbox/Projects/ds/test
 1 /Project/Warnest/docs
 2 /tmp
? 2
/tmp ~/Dropbox/Projects/ds/test /Project/Warnest/docs

# or choose by substring match
$ pd
 0 /tmp
 1 ~/Dropbox/Projects/ds/test
 2 /Project/Warnest/docs
? doc
/Project/Warnest/docs /tmp ~/Dropbox/Projects/ds/test

# substring without prompt
$ pd test
~/Dropbox/Projects/ds/test /Project/Warnest/docs /tmp

etc. Obviously this is just for rotating through the stack and doesn't handle adding new paths - maybe I should rename it.

Answer 5

I use alias in bashrc to do those cds.
such as:

alias wdoc='cd ~/Project/Warnest/docs'
alias dstest='cd ~/Dropbox/Projects/ds/test'

Answer 6

Use "pushd -n" (assuming you use bash).

Add to your ~/.bashrc:

pushd -n /Project/Warnest/docs/
pushd -n ~/Dropbox/Projects/ds/test/

then,

cd ~ is your home,

cd ~1 is ~/Dropbox/Projects/ds/test/

cd ~2 is /Project/Warnest/docs/

You can use ~1,~2 etc in exactly the same way as ~.

Answer 7

I found a script (typically called acd_funch.sh) that solved this issue for me. With this you can type cd -- to see the last 10 directories that you've used. It'll look something like this:

0  ~/Documents/onedir
1  ~/Music/anotherdir
2  ~/Music/thirddir
3  ~/etc/etc

To go to ~/Music/thirddir just type cd -2

References

• scripts/acd_func.sh
• SkyRocknRoll / acd_func.sh

NOTE: This script was originally published in a linux gazette article which is available here: acd_func.sh -- extends bash's CD to keep, display and access history of visited directory names.

Answer 8

Try the cdable_vars shell option in bash. You switch it on with shopt -s cdable_vars.

Then you need to set your variables export dir1=/some/path. and finally cd dir1, etc. You can then put it in your ~/.bashrc to make it stick.

Answer 9

There are a lot of good suggestions here. Which to use would depend on whether you have a small fixed list of directories you switch among, or whether you are looking for a more generic solution.

If it's a small fixed list, setting up simple aliases (as Felix Yan suggested) would be easiest to use.

If you're looking for a more generalized solution (i.e. many different directories, changing over time), I'd use pushd and popd (as Useless suggested). I personally find the default pushd/popd to be hard to use, especially as you start switching among many folders; however I wrote a few tweaks that make it much easier for me. Add the following to your bashrc:

alias dirs='dirs -v'
pd () 
{ 
    if [ -n "$1" ]; then
        pushd "${1/#[0-9]*/+$1}";
    else
        pushd;
    fi > /dev/null
}

• Use pd (as a shorter form of pushd) to jump to a new folder, remembering where you were.
• Use dirs to see the list of saved directories.
• Use pd 3 to jump to directory number 3.

Example Usage:

$ PS1='\w\$ '   ## just for demo purposes
~$ pd ~/Documents/data
~/Documents/data$ pd ../spec
~/Documents/spec$ pd ~/Dropbox/Public/
~/Dropbox/Public$ pd /tmp
/tmp$ pd /etc/defaults/
/etc/defaults$ dirs
 0  /etc/defaults
 1  /tmp
 2  ~/Dropbox/Public
 3  ~/Documents/spec
 4  ~/Documents/data
 5  ~
/etc/defaults$ pd 2
~/Dropbox/Public$ dirs
 0  ~/Dropbox/Public
 1  ~/Documents/spec
 2  ~/Documents/data
 3  ~
 4  /etc/defaults
 5  /tmp
~/Dropbox/Public$ pd 4
/etc/defaults$ dirs
 0  /etc/defaults
 1  /tmp
 2  ~/Dropbox/Public
 3  ~/Documents/spec
 4  ~/Documents/data
 5  ~
/etc/defaults$ pd 3
~/Documents/spec$ popd
~/Documents/data ~ /etc/defaults /tmp ~/Dropbox/Public
~/Documents/data$ 

Answer 10

The following appeared to work on the one case I tested it on, and you can just drop your directory names as symlinks in ~/Bookmarks:

mkdir "$HOME/Bookmarks"
ln -s /tmp "$HOME/Bookmarks/testdir"

function ccd() { cd $(readlink "$HOME/Bookmarks/$1") ; }

ccd testdir && echo $PWD
# gives /tmp

Answer 11

You could do worse than try j2.

From the README:

Spend a lot of time cd-ing around a complex directory tree?

j keeps track of where you’ve been and how much time you spend there, and provides a convenient way to jump to the directories you actually use.

I use it extensively & recommend it.

Answer 12

I also use these aliases (add them to ~/.bashrc):

alias ..='cd ..'
alias ...='cd ../..'
alias ....='cd ../../..'
alias .....='cd ../../../..'

It's much quicker to go to the upper directory with them (yet it only solves half of the navigation).

Answer 13

I'd advice using zsh, that shell as very good TAB completion for directories, files, and even options for most cli programs.

I've been using that shell for years now, and I'd miss the functionality if it was gone. Scripting the zsh is a lot of fun, too, with a large number of one-liners that can help you every day.

Answer 14

In my experience, the greatest speedup in navigating in a shell is to use its history search functionality. In Bash you can search backwards in your history of commands by pressing Ctrl+R and type in some pattern. That pattern is then matched against previous entries in your history -- may it be cd commands or other operations -- and suggestions are made as you type. Simply hit enter to run the suggested command again. This is called reverse-search-history in Bash and I love it. It saves me a lot of keystrokes and spares my internal memory.

It's a good thing because you only have to remember some smaller part of a command, like Drop or Wa to distinguish between the two history entries cd ~/Dropbox/Projects/ds/test/ and cd /Project/Warnest/docs/.

Answer 15

if you're using zsh:

• you don't have to type cd, just type directory path (/foo/bar/baz<Enter> equals to cd /foo/bar/baz<Enter>)

  requires auto_cd option to be set

• you can expand abbreviated paths with Tab key (/u/sh/pi<Tab> expands to /usr/share/pixmaps; works for file names as well)

Answer 16

You never ever should type full path in shell anyway. You always can use:

soffice /P*/W*/*/mydoc*

instead of

soffice /Project/Warnest/docs/mydoc.odt

Answer 17

There is a rather nice tool for quick directory changes:

xd - eXtra fast Directory changer http://xd-home.sourceforge.net/xdman.html

a bit awkward is that you need to map it in bash profile or similar as it only outputs the directory

# function to do `cd` using `xd`
# -g turns generalized directory search command processing on
# which improves the whole thing a bit
f() 
{
        cd `/usr/bin/xd -g $*`
}

you can do things like:

# change to /var/log/a* (gives you a list to choose from)    
f vla
# to skip the list and go directly to /var/log/apache2
f vlapach

Answer 18

Try https://pypi.org/project/fastcd/ It sets hook that records visited directories from bash. And sets script as "j" alias, that shows you the last visited directories, with the ability to quickly cd (start typing to filter directories).

Answer 19

Update (2016): I now use FASD for this, which allows fuzzy search based on your latest directories.

---

I've created a tool for this, in Ruby. It allows you to use YAML files to declare your projects.

I've wrote a little article about it here: http://jrnv.nl/switching-projects-terminal-quickly/

I've also posted the source on GitHub: https://github.com/jeroenvisser101/project-switcher

Answer 20

I had the same question, and first found this answer. I installed the utility z (https://github.com/rupa/z).

This is exactly what you look for, because z learns from your cd commands, and keeps track of the directories according to the frecency principle (frequent & recent). So after you do both cd commands once, you can do somtehing like:

z docs
z ds

to jump to /Project/Warnest/docs/ and ~/Dropbox/Projects/ds/test/ respectively. The arguments to z are regexes, so you don't even need to type a full folder name.

Answer 21

There's also OLDPWD, an environment variable which, according to IEEE 1003.1 (POSIX), should be updated with the previous working directory each time cd changes the working directory (for the curious ones, line 80244 of page 2506 of IEEE 1003.1-2008).

Answer 22

There is also a "wcd" app created specifically for this (also ported to cygwin, since I am on that). You can create shortcuts, bookmarks of dirs with it. Also supports wild cards. Reading the man page & docs in /usr/share/wcd should help a lot.

http://manpages.ubuntu.com/manpages/hardy/man7/wcd.7.html

Answer 23

cdargs is the most efficient tool for bookmarking a directory: http://www.youtube.com/watch?v=uWB2FIQlzZg

Answer 24

I've been using my own utility cdhist to manage this for many years. It aliases your cd command and automatically keeps a directory stack.

Answer 25

It seems that what you need is basically a project file for your workflow. With directories that belong to your activity, like in a programming IDE. Try Zsh Navigation Tools and the tool n-cd there. It will allow you to navigate across last visited folders and also define a Hotlist with directories of your choice:

n-cd can be bound to a key combination with:

zle -N znt-cd-widget

bindkey "^T" znt-cd-widget

Answer 26

TL;DR

1. Use an Fish for interactive shell that empower you immediately (fish>zsh>bash).
2. Use POSIX/Bash for scripting that is the most widely supported syntax (POSIX>Bash>Zsh>Fish).

Shells

Having tested different shells here is my feedback (in order of testing/adoption):

• Bash:
  • auto-completion: basic ;
  • path expansion: no ;
  • scripting: excellent.
• Zsh+oh-my-zsh:
  • auto-completion: good (cycling through);
  • path expansion: yes (cd /e/x1 → cd /etc/X11/) ;
  • scripting: good.
• Fish+oh-my-fish (current) is the best out of the box:
  • auto-completion: native and supported options;
  • path expansion: yes ;
  • scripting: too much difference from POSIX-compatible.

Use meaningful aliases

Every shell can be expanded using function and alias, here are the ones I use related to your issue (POSIX-compatible):

back () {  # go to previous visited directory
        cd - || exit
}

up () {  # go to parent directory
        cd ..|| exit
}

There are basic, but really meaningful so easy to remember and autocomplete.

Know your shell

Configure CDPATH to add your most used directories (e.g. ~/projects/, /etc/init.d/) so you can quickly jump to them.

See manatwork answer for mroe details on CDPATH.

Hangout and read

• my customization are on github: posix (bash/zsh), fish (PR accepted) ;
• various utilities that might be interesting: tree, k (Directory listings for zsh)
• entry-points to find plugins for your shell:
  • bucaran/awesome-fish,
  • unixorn/awesome-zsh-plugins,
  • alebcay/awesome-shell
• bashFAQ ;
• Fish documentation ;
• for differences between shells, I recommend the excellent hyperpolyglot.org/unix-shells comparison.
• on their IRC: #bash, #zsh, #ohmyzsh, #fish, etc. there is a lot of nice people (you'll need to be patient young padawan).

Answer 27

You can use export to assign your directory paths to variables and then reference them.

export dir1=/Project/Warnest/docs/
export dir2= ~/Dropbox/Projects/ds/test/
cd $dir1
cd $dir2

Answer 28

I never did like pushd and popd because they require foresight. Screw that, let's just keep track of the last several directories on our own and then make them available with a cd-to-old-dirs function. I call it cdo.

Put these two code blocks into your rc file (e.g. ~/.bashrc or ~/.zshrc):

# cdo: smarter directory history management
function precmd() { __cdo_log; }    # to install in zsh, harmless in bash
PROMPT_COMMAND="__cdo_log"          # to install in bash, harmless in zsh

# Populate the array DIRHIST with the last 9 dirs visited (not for direct use)
_cdo_log() {
  local d dh first=true
  if [[ -d "$__DIRHIST" && "$__DIRHIST" != "$PWD" ]]; then
    # $__DIRHIST is the last dir we saw, but we miss foo in `cd foo; cd bar`
    # so we use $OLDPWD to catch it; so you'd need a THIRD change to fool us.
    for d in "$__DIRHIST" "${DIRHIST[@]}"; do
      if [[ -n "$first" ]]; then unset DIRHIST first; DIRHIST[1]="$OLDPWD"; fi
      if [[ "$OLDPWD" == "$d" || "$PWD" == "$d" || ! -d "$d" ]]; then
        continue
      fi
      dh=$((1+${#DIRHIST[@]}))
      [ $dh -lt 9 ] && DIRHIST[$dh]="$d" # push up to eight directories
    done
  elif [ -z "$__DIRHIST" ]; then
    DIRHIST[1]="$OLDPWD"
  fi
  __DIRHIST="$PWD"
}

# zsh completion
command -v _describe >/dev/null 2>&1 && compdef _cdo cdo && _cdo() {
  local -a dh
  local d i=1
  for d in "${DIRHIST[@]}"; do dh+=("$((i++)):$d"); done
  _describe 'directory history' dh
}

This maintains a list of your eight more recently used directories (plus the current directory makes nine). I chose 8 because it wraps more nicely when you request a listing.

Bash completion doesn't have descriptions and there's nothing to complete since these are all a single character (do you really want a list of 1-8 digits?) but Z-shell completion is different. See below the code for an example.

Now the function itself:

cdo() {
  local d n=0 t='~' error="Usage: cdo [NUM|ls]"
  if [[ "$1" == ls ]]; then
    for d in "${DIRHIST[@]}"; do echo "$((n=n+1)) <${d/$HOME/$t}>"; done \
      |column |GREP_COLORS='ms=0;32' grep --color -e '\b[0-9] <' -e '>'
  elif [[ 0 -eq "$#" || 0 -eq ${#DIRHIST[@]} ]]; then
    cd ${OLDPWD+"$OLDPWD"}
  elif test "$1" -le "${#DIRHIST[@]}" 2>/dev/null; then # zsh [[ ]] breaks here
    cd "${DIRHIST[$1]}"
  elif [[ -d "$1" ]]; then
    cd "$1"
  else
    test "$1" -gt "${#DIRHIST[@]}" 2>/dev/null \
      && error="cdo log only has ${#DIRHIST[@]} items, try \`cdo ls\`"
    echo "$error" >&2 && return 2
  fi
}

This is basically a switch statement. First, we see if it's a listing request (cdo ls). In that case, we'll loop through the list and number them, then we use column to push it into columns. Coloring the numbers and braces dark green (0;32) with grep is convenient because it has to run after column (otherwise the widths will be off from the colors' control characters).

Second, if we're given zero arguments or there is no saved history, just use $OLDPWD or else go to the home directory if $OLDPWD is blank.

Third, see if we have a number that's no higher than the history's size (errors from being given a directory will silently fail this condition). Go to that directory number.

If it's a directory, go there. Order is important; given cdo 8 with a history of six items but a directory named 8 will just go to that directory.

Finally, we have our errors. Either we say the number is too high or we give the usage, returning with error code 2 (typically used to denote invalid arguments).

---

The following example uses a prompt of hash directory dollar (# dir $), chosen because Stack Overflow will make prompts gray:

# ~ $ cd /tmp
# /tmp $ cdo
# ~ $ cdo ls
1 </tmp>
# ~ $ cd /
# / $ cdo ls
1 </home/adam>  2 </tmp>
# / $ cdo
# ~ $ cdo ls
1 </>   2 </tmp>
# ~ $ cdo 2
# /tmp $ cd test
# /tmp/test $ cd ../test2
# /tmp/test2 $ cdo ls
1 </tmp/test>   3 </home/adam>
2 </tmp>        4 </>
# /tmp/test2 $ cdo 4
# / $ cd
# ~ $ cdo ls
1 </>           3 </tmp/test>
2 </tmp/test2>  4 </tmp>

Here's what the zsh tab completion looks like (pretend <tab> is a Tab keypress):

# ~ $ cdo <tab>
directory history
1  -- /
2  -- /tmp/test2
3  -- /tmp/test
4  -- /tmp

It's really neat to see that other people have had the same general idea as me (I thought I had been original!). @SamTroliman's mention of fastcd, @null's xd, and @phildobbin's j2 all look quite similar. See also duplicate question 84445, which has a zsh answer using setopt auto_pushd. I still prefer my own code, but ymmv.

Answer 29

anc is a cmd line tool (short for anchor), that keeps bookmarks of directories. (so far only tested with bash)

In your case:

anc a /Project/Warnest/docs/ ~/Dropbox/Projects/ds/test/

this adds both directories to the anchor(think bookmarks) list

now if you want to jump to /Project/Warnest/docs/ from anywhere on your system type:

anc Warn

and if you want to jump to ~/Dropbox/Projects/ds/test/ type:

anc ds test

Apart from matching text against the bookmarked paths anc has many other convenient ways for jumping around directories.

anc i

starts the interactive mode, that lists all bookmarks by number, so all you have to type is the number

If you type:

anc Pro[TAB]

a list matching all bookmarks (in your case both bookmarks) gets shown and you can select from it using your arrow keys, this is a very quick and intuitive way.

Get anc at the project's github page: https://github.com/tobimensch/anc

There's also a README with example usage.

Full disclosure: I'm the author of this script. I hope some people will find it useful.

Answer 30

Some suggestions here:

Most direct idea, I will add alias in the .profile file

vi ~/.profile
alias dir1='cd /myhome/onedir'
alias dir2='cd /jimmy/anotherdir'

Then use $ dir1 or dir2, can cd

If you are always switching in two dirs only. using cd - will switch between them.

Answer 31

The solution I use for this situation is screen. Start screen and create a window for each directory with C-a c and navigate there. Change between windows/directories with C-a n or C-a p. Name the windows with C-a A. Then you can pop up a list of your windows with C-a " and navigate using the window number or name. Since it is screen, you can detach from the session saving your work space and re-attach later with the same set up.

Answer 32

Based on your criteria, I think simply defining an alias for each frequently used path in your ~/.bashrc is the way to go. I use this method personally.

alias taxes='cd /users/bob/documents/home/finances/taxes'
alias elvis='cd /dropbox/2016/files/music/elvis'

As I mentioned for a related question (link), if you've gone down the directory tree and want to go back up, .. is my personal favorite. You can jump around within a branch of the tree quite easily with .. going up one directory and ../.. two and ../../.. three, etc. You can also go up and down a different branch with the same command, such as cd ../../example or cd ../../../example/example etc. For a simple switch that goes back and forth between directories, cd - or $OLDPWD are your best bets.

Answer 33

I have implemented 2 bash functions:

cdh (cd history): it auto-remembers the last 9 directories und you can back to one of them by entering the number.

cdb (cd bookmarks): you can assign any character to the current directory and later go to this directory by entering this character.

cdh and cdb both work with autocd (aka "cd witout cd").

See http://fex.belwue.de/fstools/bash.html

Answer 34

working directory(wd) from atomic seems to be a good package for this: https://github.com/karlin/working-directory

Answer 35

By far the best solution for rapid directory navigation in bash and zsh terminals is to install z - jump around script. This must-have script came recommended by Google Chrome Devtools developer, Paul Irish, in his 2013 Fluent keynote. I can't live without it.

DESCRIPTION Tracks your most used directories, based on 'frecency'.

After a short learning phase, z will take you to the most 'frecent' directory that matches ALL of the regexes given on the command line, in order.

For example, z foo bar would match /foo/bar but not /bar/foo.

[...]

Frecency is a portmanteau of 'recent' and 'frequency'.

Answer 36

I've written a script just for that. Here's the link to it on Github.

Here is an example usage:

Let's add a pev variable first:

$ pev add longpath '/A/very/very/long/path/I/frequently/need'
# output:
# environment variable "pev_longpath" added successfully. "pev show" to see the list of pev variables.

Now let's see a list of pev variables defined so far:

$ pev show
# output:



  
NAMES          VALUES




  
pev_longpath   "/A/very/very/long/path/I/frequently/need"

Then change directory to it:

$ cd $pev_longpath

or copy something into one of its subdirectories:

$ cp somefile $pev_longpath/and/deeper/than/that

---

In fact, pev variables are no different from other environment variables, they're just probably easier to manage. Please feel free to tell me my errors since I don't have much experience with shell scripting. HTH.