How to navigate directories faster with Bash (2015) (opens in new tab)

Here is one additional bookmark solution [1]:

    export CDPATH=.:~/.marks/

    function mark {
      ln -sr "$(pwd)" ~/.marks/"$1"
    }

    mark @name      # create a bookmark
    cd @name        # jump to bookmark
    cd @<tab>       # list bookmarks
    cd @n<tab>      # auto-complete
    cd @name/<tab>  # can access sub-directories within bookmarks

Works best when bookmarks are prefixed by "@" or other special symbol. Additional advantage is that you can use the same function `cd` to navigate both bookmarked and regular directories.

[1]: http://karolis.koncevicius.lt/posts/fast_navigation_in_the_c...

I upvoted for this alone:

  Another neat short hand is !$ which is an alias for the last argument of the previous command. This can be handy if one creates a new directory and wants to change into it without typing the the directory again. So commands would be

  mkdir -p make/new/directory
  cd !$

You've no idea how many years I've been thinking "This is Linux fer gawd's sake. Surely there must be some easy way to make a new directory and 'cd' to it in a single command!" But was never able to find or guess the right incantation.

The most important tool I found for switching directories is called "z". You just partially type a previously visited directory's name and it takes you there. It also keeps track of your history to rank candidates for popularity. https://github.com/rupa/z/ It's basically CDPATH on stereoids and doesn't require preconfiguration like CDPATH.

The author missed to mention one of my favorite tricks to change back in to the last visited directory:

  cd -

Hint: Change into directory called '-' can be done by

  cd ./-

I also use the mkcd alias / function:

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

This allows creating multiple dirs and cd into the first one.

  mkcd test1 test2 test3

I use `z` as a less manual way to search common directories instead of changing $CDPATH. It's based on 'frecency'.

https://github.com/rupa/z

Or you just use a shell like fish that already comes with a lot of useful defaults. No need to customize everything by yourself, just use what other smart people already created.

https://fishshell.com/

I'm surprised autocd was not mentioned. I saw

  alias ..='cd ..'
  # etc ...

But not.

  shopt -s autocd

zsh also has this. This seems like the fastest way to navigate since you no longer need to type, or retype, cd.

Another one:

  cdof () {
    cd "$(dirname $1)"
  }

as in 'Change into Directory Of"

Changes into the directory of a file. This is useful when you're doing complicated commands with long path names, but realize it would be easier if you were to cd into that directory. Use in combination with <Alt+.>. Especially useful if the filename component is long:

  $ pwd
  => ~/
  $ ls -l path/to/whatever/deep/somewhere/2021-04-22-filewithverylongnamefoobarbaz.xyz
  $ cdof <Alt+.>
  $ pwd
  => path/to/whatever/deep/somewhere

Good selection of tips, like Normille I didn't know $! even though I have read Bash's man page through more than once.

Note that many of these are not just for Bash. pushd/popd is near universal among shells and CDPATH is standard among SYSV shells.

The idea of a shortcut for cd .. and its repetitions is good, but I'd prefer alias p='cd ..', pp='cd ../..' and so on, since I balk at the idea of having to distinguish, e.g., ..... and ...., but I find pppp and ppp are easier to discriminate by eyeball.

The shells I use most often are bash and the Emacs eshell, and over the years I appreciate eshell more and more. It has a few footguns, but the availability of the various selection-narrowing libraries, dired and tramp are huge pluses. zsh can pretty much do anything bash can do and more, and it's default on Macos and Arch Linux.

https://github.com/junegunn/fzf also has a “cd mode”, by default triggerable using Alt-C, which can be useful.

I use jump commands:

export MARKPATH=$HOME/.marks function jump { cd -P $MARKPATH/$1 2>/dev/null || echo "No such mark: $1" } function ju { cd -P $MARKPATH/$1 2>/dev/null || echo "No such mark: $1" } function mark { mkdir -p $MARKPATH; ln -s $(pwd) $MARKPATH/$1 } function unmark { rm -i $MARKPATH/$1 } function marks { ls -l $MARKPATH | sed 's/ / /g' | cut -d' ' -f9- | sed 's/ -/\t-/g' && echo }

I think the original source is #http://jeroenjanssens.com/2013/08/16/quickly-navigate-your-f...

Another neat trick is to set you .inputrc to vi mode with

set editing-mode vi set keymap vi

and then put this in your .bashrc

bind -m vi-insert -x '"\C-h"':'"pushd . 1>/dev/null 2>/dev/null && cd ../ && echo -e ${LILA} $PWD && ls"' bind -m vi-insert -x '"\C-n"':'"popd 1>/dev/null 2>/dev/null && echo -e ${LILA} $PWD && ls"' bind -m vi-insert -x '"\C-b":"cd $HOME && echo -e ${LILA} $PWD && ls"'

This enables you to go a directory up using ctrl-h and go back using ctrl-n.

I have a few functions in my bashrc for fast directory navigation.

up <#> - cd .. # times

upto <dir> - find dir in the current path above you and cd to it

down <dir> - find dir in the current tree below you including inside any number of subdirectories and cd to it

https://github.com/robmccoll/dotfiles/blob/master/bashrc#L15...

I've been playing around with the tool FZF recently. It's speeding up my command line workflow quite a lot. I made a small script that allows me to open a fuzzy search for any command, so I can write the command f followed by something like vim, evince, cd, mpv... I can optionally give a starting directory and a first query but I rarely do it. I have it in my .bashrc, but should work in any posix compliant shell. It needs fzf and fd:

  # fuzzy search any command
  f(){
    ROOT_DIR="."
    [ -n "$2" ] && ROOT_DIR="$2"
    FZF_OUT=`fd . -H --color=always "$ROOT_DIR" --exclude "Software/"| fzf --query="$3"`
    [ -n "$FZF_OUT" ] && "$1" "$FZF_OUT"
  }

in my case Software/ is a directory with lots of files I don't need so I exclude it from my searches. I also like using ranger, it has very nice bookmarking and launcher features.

Honestly what made the most difference for me was learning that `cd -` is "go back".

Works for git too:

`git checkout -` (checkout previous branch)

`git merge -` (merge with previous branch; useful for pulling master before merging)

I exhort you all to take a look at Fasd:

https://github.com/clvv/fasd

No mentions of https://github.com/jarun/nnn yet?

I've really taken a shine to using a real file manager with lots of nifty features without any bloat.

I do the following [1]:

- I define "cdn" to be what others call "mkcd", as then if I have a command line "cd foo" and it tells me that foo doesn't exist, I can just add the 'n' to the previous entry. I also overload "cdn" so that when not given any argument, it goes into the newest subdirectory in the current directory.

- "u", "uu", "uuu", "uuuu", "uuuuu" for going "up" that many levels, and unlike the aliases in OP, I define them as functions and if those are given an argument, they descends into the path from there: "u foo" is equivalent to "cd ../foo", "uu foo" to "cd ../../foo".

- I also have a function called "mvcd foo bar" that moves foo to bar and then goes into bar. "mvcdnewdir foo bar" that does the same but will create bar. (I'm pondering unifying them to a version that always calls mkdir -p)

- an alias "c" for cd [2]. The single letter messes with the history search though (ctl-r c space or ctl-r cd space ?), so it's not necessarily a good idea. `shopt -s autocd` that I just learned about here may be better.

- some functions for special locations, "cs" for ~/scratch, "cb" for ~/bookmarks, etc.

[1] see .bashrc at https://github.com/pflanze/chj-home [2] but I never use bash's "alias" since aside of being shorter it is always worse than a function (no way to extend it later to take parameters, and messes up live redefinitions)

I vote for creating a « mkcd » alias !!

I independently also have a stack of '...', '....' etc aliases almost exactly the same as this! Extremely useful I reckon!

Another thing that I've found surprisingly invaluable is an alias (i went for 'ccd') that figures out (via python, so a bit slower on the 1st run) what part of the argument is a valid directory and then cd's you there. It's very handy indeed when working with file paths all the time (a film-vfx-on-Linux use-case) otherwise you end up using backspace to delete the file part constantly! In fact, about that: hitting Esc-Backspace in sequence, should delete back to the next word separator instead of one char at a time.

For me once I moved to zsh and added `oh my zsh` it really became so much easier.

I like the autocomplete, the fact that when cd-ing a known path you can just type the first leter of each directory with slashes, showing the git branch in working dir.

Its the little things.

I just read the title and thought "Switch to Zsh".

Bash is so amazingly clunky in comparison.

I haven’t tested this exact scenario but I like doing something like this when needed

    mkdir -p path/to/{one,two,three}/done

To create:

* path/to/one/done

* path/to/two/done

* path/to/three/done

We tried to somewhat mimic the finder experience when implementing directory navigation at Fig (https://withfig.com). Except of course, we make it all keyboard driven!

The methods listed in the article are almost certainly better if you know exactly which directory you need to go to (like a specific project repo, your bin etc) however often you don’t!

Another interesting tool is Z: https://github.com/rupa/z

On a Mac, Findspot supports fuzzy directory search, either as a key sequence or via the command line (my alias is "c").

https://gumroad.com/l/findspot

I experiment with many forms of automation and stick with few of them. Interface complexity has a cost; there's a reason keyboards don't have more keys. For me, Findspot is indispensable.

FWIW I learnt a lot of my Bash tricks from: https://www.commandlinefu.com/

One of my favorite custom bash function is to use up() function to abstract away all the cd ../../../ command.

Up 3 will put me 3 directories behind the current one.

I have been using this "magic cd" alias for a while. You just type c and then the name of a folder, and it will find the most commonly visited folder with that name from your history and send you to it. It also supports tab completion.

https://gist.github.com/iwalton3/3f9bfce510f959782404be25cab...

My preference is "u" for "up":

> alias u="cd .."

And on Dvorak, "u" is under the left index finger. Can't get faster than that ;)

I'm using this bash script that adds a web-browser like history management (going forward with "+" and backward with "-"). It's been used for a couple of decades now.

https://gist.github.com/euske/4f06a6e060131949085c493bd28a0c...

edit: url

Wow I’m just blown away by this.

Really cool trick to navigate directories fast I’m definitely going to add this to my .zshrc

Honestly commandline has made so many things easier for me that I don’t even use regular apps besides my browser for browsing web anyhow using commandline has really made me productive

And I always look for automating or making the workflow better

Anyways great post thanks for sharing:)

I happily use bashmarks to jump to well known directories

https://github.com/huyng/bashmarks

  cd /path/to/project1
  s p1 # sets bookmark
  cd /elsewhere
  g p1

It also autocompletes bookmarks.

I use zoxide: https://github.com/ajeetdsouza/zoxide

There're only few directories I need to change to daily. So when I have to visit them, I need to type only `z first_two_characters_of_the_directory_name`

These sorts of things are really useful and it's one of the reasons I think everyone should keep their dotfiles on github or similar so they can share their little tricks. Mine are just a compilation of stuff like this that I've picked up from other people over the years. (I even try to put attributions in there if I got them from friends)

My favorite one is c to change to my ~/code directory with tab completion from anywhere. So I can type c pr<tab><enter> to cd in to ~/code/project from anywhere. (Full disclosure This is zsh and I don't have a bash equivalent for that)

Another thing I can't live without and some people hate is ls -la anytime I cd in to a directory. In a gui, I get that visual feedback immediately and it's usually the first thing I type when I land anyway so I just have a function for it https://github.com/gpspake/dotfiles/blob/master/zsh/gpspake/...

Is it me or the elephant in the room is : you can't augment regular "cd" functionality for autocomplete (for example via fzf) without resorting to super intricate bash code ? And so one has to introduce a new command to "replace" cd ?

Those bunch of dots aliases are a bit ridiculous. What are you gonna do, sit and count dots?

Not a word about command editing.

Learn keyboard shortcuts to edit the current command line and you'll save years of your life.

ESC-. (dot) will get the last argument of the last command. This one alone will save you months.

CTRL-R will search backwards. This other will save more months.

If you frequently need to switch between several git branches, pushb and popb are useful commands.

https://github.com/pwoolcoc/pushb

https://github.com/ranger/ranger nobody? And as others have pointed out, fasd and fzf of course.

Vim is a good way to browse directories also! Run "vim ." to see. It's nice because you can search folder names to jump to them (in the same way you'd search any other file).

And if you want to make bash history usable, use hstr [1].

[1] https://github.com/dvorka/hstr

> Maybe less well-known is that ~ is an alias for one’s home directory.

And ~mylogin is another alias for ones home directory.

And more generally, ~otherdev is an alias for otherdev's home directory.

The cdable_vars bash option is among my favorites

  shopt -s cdable_vars
  p=/some/path/you/cd/to/a/bunch
  cd p

Figure I might as well share an alias I get some use out of.

  alias gd='cd "$(git rev-parse --show-toplevel)"'

I've heard so many horror stories about bugs related to CDPATH that I immediately assume it's a bad idea to have one now.

OT a bit, but while I don‘t use it often, sometimes fzf really takes the pain out of navigation.

Anther thing I regularily use is incrementally searching backward in the history with C-r.

Would it possible to alias the escape codes make by the up arrow as 'cd ..'

I know this is about bash, but for zsh, autojump is absolutely amazing.