Mdthbs

In bash:

directory_to_remove=/d/Programme/cygwin/bin

PATH=:$PATH:

PATH=${PATH//:$directory_to_remove:/:}

PATH=${PATH#:}; PATH=${PATH%:}

If you don't use an intermediate variable, you need to protect the / characters in the directory to remove so that they aren't treated as the end of the search text.

PATH=:$PATH:

PATH=${PATH//:/d/Programme/cygwin/bin:/:}

PATH=${PATH#:}; PATH=${PATH%:}

The first and third line are there to arrange for every component of the search path to be surrounded by :, to avoid special-casing the first and last component. The second line removes the specified component.

After considering other options presented here, and not fully understanding how some of them worked I developed my own path_remove function, which I added to my .bashrc:

function path_remove {

  # Delete path by parts so we can never accidentally remove sub paths

  PATH=${PATH//":$1:"/":"} # delete any instances in the middle

  PATH=${PATH/#"$1:"/} # delete any instance at the beginning

  PATH=${PATH/%":$1"/} # delete any instance in the at the end

}

This ended up pretty close to Gilles' solution but wrapped up as a bash function which could be easily used on the command line.

It has the advantages that as a bash function it works like a program without needing to be a program on the path, and it doesn't require any external programs to run, just bash string manipulation.

It appears pretty robust, in particular it doesn't turn somepath:mypath/mysubpath into somepath/mysubpath:if you run path_remove mypath, which was a problem I had with my previous path_remove function.

An excellent explanation of how bash string manipulation works can be found at the Advanced Bash-Scripting Guide.

So, combining the answers from @gilles and @bruno-a (and a couple of other sed tricks) I came up with this one-liner, which will remove (every) REMOVE_PART from PATH, regardless of whether it occurs at the beginning, middle or end of PATH

PATH=$(REMOVE_PART="/d/Programme/cygwin/bin" sh -c 'echo ":$PATH:" | sed "s@:$REMOVE_PART:@:@g;s@^:(.*):$@1@"')

It's a bit unwieldy, but it's nice to be able to do it in one hit. The ; is used to join together the two separate sed commands:

• 
  s@:$REMOVE_PART:@:@g (which replaces :$REMOVE_PART: with a single :)


• 
  s@^:(.*):$@1@ (which strips off the leading and trailing colons we added with the echo command)

And along similar lines, I've just managed to come up with this one-liner for adding a ADD_PART to the PATH, only if the PATH doesn't already contain it

PATH=$(ADD_PART="/d/Programme/cygwin/bin" sh -c 'if echo ":$PATH:" | grep -q ":$ADD_PART:"; then echo "$PATH"; else echo "$ADD_PART:$PATH"; fi')

Change the last part to echo "$PATH:$ADD_PART" if you want to add ADD_PART to the end of PATH instead of to the start.

...

...or to make this even easier, create a script called remove_path_part with the contents

echo ":$PATH:" | sed "s@:$1:@:@g;s@^:(.*):$@1@"

and a script called prepend_path_part with the contents

if echo ":$PATH:" | grep -q ":$1:"; then echo "$PATH"; else echo "$1:$PATH"; fi

and a script called append_path_part with the contents

if echo ":$PATH:" | grep -q ":$1:"; then echo "$PATH"; else echo "$PATH:$1"; fi

make them all executable, and then call them like:

• PATH=$(remove_path_part /d/Programme/cygwin/bin)


• PATH=$(prepend_path_part /d/Programme/cygwin/bin)


• PATH=$(append_path_part /d/Programme/cygwin/bin)

Neat, even if I say so myself :-)

It is an interesting exercise to write a bash function to remove a directory from a path variable.

Here are some functions I use in my .bash* files to append/prepend directories to paths. They have the virtue of removing duplicate entries, if any, and work with any kind of colon separated path variable (PATH, MANPATH, INFOPATH, ...). the remove_from function removes the directory.

# {app,pre}pend_to path-var-name dirpath

# remove_from path-var-name dirpath

#

# Functions to manipulate a path-style variable.  {app,pre}pend_to

# both remove any other instances of dirname before adding it to

# the start or end of the path-var-name variable.

#

# Calling example:

#   append_to PATH "/usr/local/bin"

#

# Uses eval to allow target path varname to be passed in.

function remove_from() {

  # add surrounging colons

  eval tmp_path=":$${1}:"

  # if dir is already there, remove it

  (echo "${tmp_path}" | grep --silent ":${2}:") &&

    tmp_path=`echo "$tmp_path" | sed "s=:${2}:=:=g"`

  # remove surrounding colons

  tmp_path=`echo "$tmp_path" | sed 's=^:==; s=:$=='`

  eval export $1="$tmp_path"

}

function append_to() {

  remove_from "$1" "$2"  # clean the path contents

  eval export $1="$${1}:$2"

}

function prepend_to() {

  remove_from "$1" "$2"  # clean the path contents

  eval export $1="${2}:$$1"

}

Below are revised code from Greg Tarsa's solution. Only bash build-in commands are used here. Thus, it will save a lots of fork() system calls.

# Calling example:

#   append_to PATH "/usr/local/bin"



function remove_from()

{

    local path="${1}"

    local dir="${2}"

    local -a dirs=()

    local old_ifs="${IFS}"

    IFS=":"

    set -- ${!path}

    while [ "$#" -gt "0" ]

    do

        [ "${1}" != "${dir}" ] && dirs+=("${1}")

        shift

        done

    eval "export ${path}="${dirs[*]}""

    IFS="${old_ifs}"

}



function append_to()

{

    remove_from "${1}" "${2}"

    [ -d "${2}" ] || return

    if [ -n "${!1}" ]

    then

        eval "export ${1}="${!1}:${2}""

    else

        eval "export ${1}="${2}""

    fi

}



function prepend_to()

{

    remove_from "${1}" "${2}"

    [ -d "${2}" ] || return

    if [ -n "${!1}" ]

    then

        eval "export ${1}="${2}:${!1}""

    else

        eval "export ${1}="${2}""

    fi

}

To complete/improve the accepted answer from Tushar, you can:

• avoid having to escape the slashes in the PATH by using non-slash delimiters


• omit the -e option, as per the sed man page: "If no -e, --expression, -f, or --file option is given, then the first non-option argument is taken as the sed script to interpret."


• use the g (global) flag to remove all occurrences

In the end, it gives something like this:

PATH=$(echo "$PATH" | sed 's@:/home/wrong/dir$@@g')

Much simpler one liner.

export PATH=`echo $PATH | tr ":" "n" | grep -v "anaconda" | tr "n" ":"`

The current answers don't solve my similar problem in that I need to remove multiple paths. All these paths are sub-directories of a single directory. In that case, this one-liner works for me: (suppose the pattern is cygwin, i.e., removing all paths that contains cygwin)

pattern=cygwin; export PATH=$(echo $PATH|tr ':' 'n'|sed "#${pattern}#d" |tr 'n' ':')