mjhjmtu

I'm trying to compile wxWidgets using MingW, and I have cygwin in my path, which seems to conflict. So I would like to remove /d/Programme/cygwin/bin from the PATH variable and I wonder if there is some elegant way to do this.

The naive approach would be to echo it to a file, remove it manually and source it, but I bet there is better approach to this.

There are no standard tools to "edit" the value of $PATH (i.e. "add folder only when it doesn't already exists" or "remove this folder").
You just execute:

export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games

that would be for the current session, if you want to change permanently add it to any .bashrc, bash.bashrc, /etc/profile - whatever fits your system and user needs.
However if you're using BASH, you can also do the following if, let's say, you want to remove the directory /home/wrong/dir/ from your PATH variable, assuming it's at the end:

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

So in your case you may use

PATH=$(echo "$PATH" | sed -e 's/:/d/Programme/cygwin/bin$//')

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 reated 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 :-)

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')

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,prepend_to path-var-name dirpath
# remove_from path-var-name dirpath
#
# Functions to manipulate a path-style variable. app,prepend_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() grep --silent ":$2:") &&
 tmp_path=`echo "$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"

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' ':')