Ou plus généralement, comment supprimer un élément d'une liste séparée par deux-points dans une variable d'environnement Bash?

Je pensais avoir vu un moyen simple de le faire il y a des années, en utilisant les formes plus avancées d'expansion variable de Bash, mais si c'est le cas, j'en ai perdu la trace. Une recherche rapide sur Google a produit étonnamment peu de résultats pertinents et aucun que j'appellerais «simple» ou «élégant». Par exemple, deux méthodes utilisant respectivement sed et awk:

PATH=$(echo $PATH | sed -e 's;:\?/home/user/bin;;' -e 's;/home/user/bin:\?;;')
PATH=!(awk -F: '{for(i=1;i<=NF;i++){if(!($i in a)){a[$i];printf s$i;s=":"}}}'<<<$PATH)

N'existe-t-il rien de simple? Y a-t-il quelque chose d'analogue à une fonction split () dans Bash?

Mise à jour:
il semble que je doive m'excuser pour ma question intentionnellement vague; J'étais moins intéressé à résoudre un cas d'utilisation spécifique qu'à provoquer une bonne discussion. Heureusement, je l'ai!

Il existe ici des techniques très intelligentes. En fin de compte, j'ai ajouté les trois fonctions suivantes à ma boîte à outils. La magie opère dans path_remove, qui repose en grande partie sur l'utilisation intelligente par Martin York de la awkvariable RS de 's.

path_append ()  { path_remove $1; export PATH="$PATH:$1"; }
path_prepend () { path_remove $1; export PATH="$1:$PATH"; }
path_remove ()  { export PATH=`echo -n $PATH | awk -v RS=: -v ORS=: '$0 != "'$1'"' | sed 's/:$//'`; }

Le seul vrai problème ici est l'utilisation de sedpour supprimer les deux points de fin. Compte tenu de la simplicité du reste de la solution de Martin, je suis tout à fait disposé à vivre avec!

Question connexe: Comment manipuler les éléments $ PATH dans les scripts shell?

Une minute avec awk:

# Strip all paths with SDE in them.
#
export PATH=`echo ${PATH} | awk -v RS=: -v ORS=: '/SDE/ {next} {print}'`

Edit: Il répond aux commentaires ci-dessous:

$ export a="/a/b/c/d/e:/a/b/c/d/g/k/i:/a/b/c/d/f:/a/b/c/g:/a/b/c/d/g/i"
$ echo ${a}
/a/b/c/d/e:/a/b/c/d/f:/a/b/c/g:/a/b/c/d/g/i

## Remove multiple (any directory with a: all of them)
$ echo ${a} | awk -v RS=: -v ORS=: '/a/ {next} {print}'
## Works fine all removed

## Remove multiple including last two: (any directory with g)
$ echo ${a} | awk -v RS=: -v ORS=: '/g/ {next} {print}'
/a/b/c/d/e:/a/b/c/d/f:
## Works fine: Again!

Modifier en réponse à un problème de sécurité: (qui n'est pas pertinent pour la question)

export PATH=$(echo ${PATH} | awk -v RS=: -v ORS=: '/SDE/ {next} {print}' | sed 's/:*$//')

Cela supprime tous les deux-points de fin en supprimant les dernières entrées, ce qui ajouterait effectivement .à votre chemin.

Mon sale hack:

echo ${PATH} > t1
vi t1
export PATH=$(cat t1)

Étant donné que le gros problème de la substitution concerne les cas finaux, pourquoi ne pas différencier les cas finaux des autres cas? Si le chemin avait déjà des deux-points au début et à la fin, nous pourrions simplement rechercher la chaîne souhaitée entourée de deux points. Dans l'état actuel des choses, nous pouvons facilement ajouter ces deux points et les supprimer par la suite.

# PATH => /bin:/opt/a dir/bin:/sbin
WORK=:$PATH:
# WORK => :/bin:/opt/a dir/bin:/sbin:
REMOVE='/opt/a dir/bin'
WORK=${WORK/:$REMOVE:/:}
# WORK => :/bin:/sbin:
WORK=${WORK%:}
WORK=${WORK#:}
PATH=$WORK
# PATH => /bin:/sbin

Pure bash :).

Voici la solution la plus simple que je puisse concevoir:

#!/bin/bash
IFS=:
# convert it to an array
t=($PATH)
unset IFS
# perform any array operations to remove elements from the array
t=(${t[@]%%*usr*})
IFS=:
# output the new array
echo "${t[*]}"

L'exemple ci-dessus supprimera tout élément de $ PATH contenant "usr". Vous pouvez remplacer "* usr *" par "/ home / user / bin" pour supprimer uniquement cet élément.

mise à jour par sschuberth

Même si je pense que les espaces dans un $PATHsont une idée horrible , voici une solution qui le gère:

PATH=$(IFS=':';t=($PATH);n=${#t[*]};a=();for ((i=0;i<n;i++)); do p="${t[i]%%*usr*}"; [ "${p}" ] && a[i]="${p}"; done;echo "${a[*]}");

ou

IFS=':'
t=($PATH)
n=${#t[*]}
a=()
for ((i=0;i<n;i++)); do
  p="${t[i]%%*usr*}"
  [ "${p}" ] && a[i]="${p}"
done
echo "${a[*]}"

Voici une ligne unique qui, malgré les réponses actuellement acceptées et les mieux notées , n'ajoute pas de caractères invisibles à PATH et peut gérer les chemins contenant des espaces:

export PATH=$(p=$(echo $PATH | tr ":" "\n" | grep -v "/cygwin/" | tr "\n" ":"); echo ${p%:})

Personnellement, je trouve également cela facile à lire / à comprendre, et cela n'implique que des commandes courantes au lieu d'utiliser awk.

Voici une solution qui:

• est du pur Bash,
• n'invoque pas d'autres processus (comme 'sed' ou 'awk'),
• ne change pas IFS,
• ne fourche pas un sous-shell,
• gère les chemins avec des espaces, et

• supprime toutes les occurrences de l'argument dans PATH.

  removeFromPath () {
     pd local
     p = ": $ 1:"
     d = ": $ PATH:"
     d = $ {d // $ p /:}
     d = $ {d / #: /}
     CHEMIN = $ {d /%: /}
  }

function __path_remove () {
local D = ": $ {PATH}:";
["$ {D /: $ 1: /:}"! = "$ D"] && PATH = "$ {D /: $ 1: /:}";
CHEMIN = "$ {CHEMIN / #: /}";
export PATH = "$ {PATH /%: /}";
}

Extrayez-le de mon fichier .bashrc. Lorsque vous jouez avec PATH et qu'il se perd, awk / sed / grep devient indisponible :-)

La meilleure option pure bash que j'ai trouvée jusqu'à présent est la suivante:

function path_remove {
  PATH=${PATH/":$1"/} # delete any instances in the middle or at the end
  PATH=${PATH/"$1:"/} # delete any instances at the beginning
}

Ceci est basé sur la réponse pas tout à fait correcte à Ajouter un répertoire à $ PATH s'il n'est pas déjà là sur Superuser.

Je viens d'utiliser les fonctions de la distribution bash, qui existent apparemment depuis 1991. Celles-ci sont toujours dans le paquet bash-docs sur Fedora, et étaient utilisées dans /etc/profile, mais pas plus ...

$ rpm -ql bash-doc |grep pathfunc
/usr/share/doc/bash-4.2.20/examples/functions/pathfuncs
$ cat $(!!)
cat $(rpm -ql bash-doc |grep pathfunc)
#From: "Simon J. Gerraty" <[email protected]>
#Message-Id: <[email protected]>
#Subject: Re: a shell idea?
#Date: Mon, 09 Oct 1995 21:30:20 +1000


# NAME:
#       add_path.sh - add dir to path
#
# DESCRIPTION:
#       These functions originated in /etc/profile and ksh.kshrc, but
#       are more useful in a separate file.
#
# SEE ALSO:
#       /etc/profile
#
# AUTHOR:
#       Simon J. Gerraty <[email protected]>

#       @(#)Copyright (c) 1991 Simon J. Gerraty
#
#       This file is provided in the hope that it will
#       be of use.  There is absolutely NO WARRANTY.
#       Permission to copy, redistribute or otherwise
#       use this file is hereby granted provided that
#       the above copyright notice and this notice are
#       left intact.

# is $1 missing from $2 (or PATH) ?
no_path() {
        eval "case :\$${2-PATH}: in *:$1:*) return 1;; *) return 0;; esac"
}
# if $1 exists and is not in path, append it
add_path () {
  [ -d ${1:-.} ] && no_path $* && eval ${2:-PATH}="\$${2:-PATH}:$1"
}
# if $1 exists and is not in path, prepend it
pre_path () {
  [ -d ${1:-.} ] && no_path $* && eval ${2:-PATH}="$1:\$${2:-PATH}"
}
# if $1 is in path, remove it
del_path () {
  no_path $* || eval ${2:-PATH}=`eval echo :'$'${2:-PATH}: |
    sed -e "s;:$1:;:;g" -e "s;^:;;" -e "s;:\$;;"`
}

J'ai écrit une réponse à cela ici (en utilisant aussi awk). Mais je ne suis pas sûr que ce soit ce que vous recherchez? Il me semble au moins clair ce qu'il fait, au lieu d'essayer de rentrer dans une seule ligne. Pour une simple doublure, cependant, qui ne supprime que des choses, je recommande

echo $PATH | tr ':' '\n' | awk '$0 != "/bin"' | paste -sd:

Le remplacement est

echo $PATH | tr ':' '\n' | 
    awk '$0 != "/bin"; $0 == "/bin" { print "/bar" }' | paste -sd:

ou (plus court mais moins lisible)

echo $PATH | tr ':' '\n' | awk '$0 == "/bin" { print "/bar"; next } 1' | paste -sd:

Quoi qu'il en soit, pour la même question, et un tas de réponses utiles, voir ici .

Eh bien, dans bash, comme il prend en charge les expressions régulières, je ferais simplement:

PATH=${PATH/:\/home\/user\/bin/}

J'aime les trois fonctions présentées dans la mise à jour de @ BenBlank à sa question d'origine. Pour les généraliser, j'utilise un formulaire à 2 arguments, qui me permet de définir PATH ou toute autre variable d'environnement que je souhaite:

path_append ()  { path_remove $1 $2; export $1="${!1}:$2"; }
path_prepend () { path_remove $1 $2; export $1="$2:${!1}"; }
path_remove ()  { export $1="`echo -n ${!1} | awk -v RS=: -v ORS=: '$1 != "'$2'"' | sed 's/:$//'`"; }

Exemples d'utilisation:

path_prepend PATH /usr/local/bin
path_append PERL5LIB "$DEVELOPMENT_HOME/p5/src/perlmods"

Notez que j'ai également ajouté des guillemets pour permettre le bon traitement des chemins d'accès contenant des espaces.

Quelle est la manière la plus élégante de supprimer un chemin de la variable $ PATH dans Bash?

Quoi de plus élégant que awk?

path_remove ()  { export PATH=`echo -n $PATH | awk -v RS=: -v ORS=: '$0 != "'$1'"' | sed 's/:$//'`; 

Python! C'est une solution plus lisible et maintenable, et il est facile d'inspecter pour voir qu'elle fait vraiment ce que vous voulez.

Voulez-vous supprimer le premier élément de chemin?

PATH="$(echo "$PATH" | python -c "import sys; path = sys.stdin.read().split(':'); del path[0]; print(':'.join(path))")"

(Au lieu de la tuyauterie de echo , os.getenv['PATH']serait un peu plus court et fournirait le même résultat que ci-dessus, mais je crains que Python puisse faire quelque chose avec cette variable d'environnement, il est donc probablement préférable de le canaliser directement depuis l'environnement qui vous tient à cœur. .)

De même pour supprimer de la fin:

PATH="$(echo "$PATH" | python -c "import sys; path = sys.stdin.read().split(':'); del path[-1]; print(':'.join(path))")"

Pour rendre ces fonctions shell réutilisables que vous pouvez, par exemple, coller dans votre fichier .bashrc:

strip_path_first () {
    PATH="$(echo "$PATH" | 
    python -c "import sys; path = sys.stdin.read().split(':'); del path[0]; print(':'.join(path))")"
}

strip_path_last () {
    PATH="$(echo "$PATH" | 
    python -c "import sys; path = sys.stdin.read().split(':'); del path[-1]; print(':'.join(path))")"
}

Oui, mettre un deux-points à la fin de PATH, par exemple, rend la suppression d'un chemin un peu moins maladroite et sujette aux erreurs.

path_remove ()  { 
   declare i newPATH
   newPATH="${PATH}:"
   for ((i=1; i<=${#@}; i++ )); do
      #echo ${@:${i}:1}
      newPATH="${newPATH//${@:${i}:1}:/}" 
   done
   export PATH="${newPATH%:}" 
   return 0; 
} 

path_remove_all ()  {
   declare i newPATH
   shopt -s extglob
   newPATH="${PATH}:"
   for ((i=1; i<=${#@}; i++ )); do
      newPATH="${newPATH//+(${@:${i}:1})*([^:]):/}" 
      #newPATH="${newPATH//+(${@:${i}:1})*([^:])+(:)/}" 
   done
   shopt -u extglob 
   export PATH="${newPATH%:}" 
   return 0 
} 

path_remove /opt/local/bin /usr/local/bin

path_remove_all /opt/local /usr/local 

Si vous êtes préoccupé par la suppression des doublons dans $ PATH, le moyen le plus élégant, à mon humble avis, serait de ne pas les ajouter en premier lieu. En 1 ligne:

if ! $( echo "$PATH" | tr ":" "\n" | grep -qx "$folder" ) ; then PATH=$PATH:$folder ; fi

Le dossier $ peut être remplacé par n'importe quoi et peut contenir des espaces ("/ home / user / my documents")

La solution pure bash la plus élégante que j'ai trouvée à ce jour:

pathrm () {                                                                      
  local IFS=':'                                                                  
  local newpath                                                                  
  local dir                                                                      
  local pathvar=${2:-PATH}                                                       
  for dir in ${!pathvar} ; do                                                    
    if [ "$dir" != "$1" ] ; then                                                 
      newpath=${newpath:+$newpath:}$dir                                          
    fi                                                                           
  done                                                                           
  export $pathvar="$newpath"                                                        
}

pathprepend () {                                                                 
  pathrm $1 $2                                                                   
  local pathvar=${2:-PATH}                                                       
  export $pathvar="$1${!pathvar:+:${!pathvar}}"                                  
}

pathappend () {                                                                    
  pathrm $1 $2                                                                   
  local pathvar=${2:-PATH}                                                       
  export $pathvar="${!pathvar:+${!pathvar}:}$1"                                  
} 

La plupart des autres solutions proposées reposent uniquement sur la correspondance de chaîne et ne prennent pas en compte les segments de chemin contenant des noms spéciaux comme ., ..ou ~. La fonction bash ci-dessous résout les chaînes de répertoire dans son argument et dans les segments de chemin pour trouver des correspondances de répertoire logique ainsi que des correspondances de chaîne.

rm_from_path() {
  pattern="${1}"
  dir=''
  [ -d "${pattern}" ] && dir="$(cd ${pattern} && pwd)"  # resolve to absolute path

  new_path=''
  IFS0=${IFS}
  IFS=':'
  for segment in ${PATH}; do
    if [[ ${segment} == ${pattern} ]]; then             # string match
      continue
    elif [[ -n ${dir} && -d ${segment} ]]; then
      segment="$(cd ${segment} && pwd)"                 # resolve to absolute path
      if [[ ${segment} == ${dir} ]]; then               # logical directory match
        continue
      fi
    fi
    new_path="${new_path}${IFS}${segment}"
  done
  new_path="${new_path/#${IFS}/}"                       # remove leading colon, if any
  IFS=${IFS0}

  export PATH=${new_path}
}

Tester:

$ mkdir -p ~/foo/bar/baz ~/foo/bar/bif ~/foo/boo/bang
$ PATH0=${PATH}
$ PATH=~/foo/bar/baz/.././../boo/././../bar:${PATH}  # add dir with special names
$ rm_from_path ~/foo/boo/../bar/.  # remove same dir with different special names
$ [ ${PATH} == ${PATH0} ] && echo 'PASS' || echo 'FAIL'

Linux from Scratch définit trois fonctions Bash dans /etc/profile:

# Functions to help us manage paths.  Second argument is the name of the
# path variable to be modified (default: PATH)
pathremove () {
        local IFS=':'
        local NEWPATH
        local DIR
        local PATHVARIABLE=${2:-PATH}
        for DIR in ${!PATHVARIABLE} ; do
                if [ "$DIR" != "$1" ] ; then
                  NEWPATH=${NEWPATH:+$NEWPATH:}$DIR
                fi
        done
        export $PATHVARIABLE="$NEWPATH"
}

pathprepend () {
        pathremove $1 $2
        local PATHVARIABLE=${2:-PATH}
        export $PATHVARIABLE="$1${!PATHVARIABLE:+:${!PATHVARIABLE}}"
}

pathappend () {
        pathremove $1 $2
        local PATHVARIABLE=${2:-PATH}
        export $PATHVARIABLE="${!PATHVARIABLE:+${!PATHVARIABLE}:}$1"
}

export -f pathremove pathprepend pathappend

Réf: http://www.linuxfromscratch.org/blfs/view/svn/postlfs/profile.html

Je sais que cette question concerne BASH, ce que tout le monde devrait préférer, mais comme j'aime la symétrie et que parfois je suis obligé d'utiliser "csh", j'ai construit l'équivalent de "path_prepend ()", "path_append ()" et "path_remove () "solution élégante ci-dessus.

L'essentiel est que "csh" n'a pas de fonctions, donc j'ai mis de petits scripts shell dans mon répertoire bin personnel qui agissent comme les fonctions. Je crée des alias pour SOURCE ces scripts pour apporter les modifications de variable d'environnement désignées.

~ / bin / _path_remove.csh:

set _resolve = `eval echo $2`
setenv $1 `eval echo -n \$$1 | awk -v RS=: -v ORS=: '$1 != "'${_resolve}'"' | sed 's/:$//'`;
unset _resolve

~ / bin / _path_append.csh:

source ~/bin/_path_remove.csh $1 $2
set _base = `eval echo \$$1`
set _resolve = `eval echo $2`
setenv $1 ${_base}:${_resolve}
unset _base _resolve

~ / bin / _path_prepend.csh:

source ~/bin/_path_remove.csh $1 $2
set _base = `eval echo \$$1`
set _resolve = `eval echo $2`
setenv $1 ${_resolve}:${_base}
unset _base _resolve

~ / bin / .cshrc:

…
alias path_remove  "source ~/bin/_path_remove.csh  '\!:1' '\!:2'"
alias path_append  "source ~/bin/_path_append.csh  '\!:1' '\!:2'"
alias path_prepend "source ~/bin/_path_prepend.csh '\!:1' '\!:2'"
…

Vous pouvez les utiliser comme ça ...

%(csh)> path_append MODULEPATH ${HOME}/modulefiles

Étant donné que cela a tendance à être assez problématique, car il n'y a AUCUN moyen élégant, je recommande d'éviter le problème en réorganisant la solution: augmentez votre PATH plutôt que d'essayer de le démolir.

Je pourrais être plus précis si je connaissais votre véritable problème. En attendant, j'utiliserai une version logicielle comme contexte.

Un problème courant avec les versions logicielles est qu'il se brise sur certaines machines, en fin de compte en raison de la façon dont quelqu'un a configuré son shell par défaut (PATH et autres variables d'environnement). La solution élégante est de rendre vos scripts de construction immunisés en spécifiant entièrement l'environnement shell. Codez vos scripts de construction pour définir le PATH et d'autres variables d'environnement en fonction des éléments d'assemblage que vous contrôlez, tels que l'emplacement du compilateur, des bibliothèques, des outils, des composants, etc. Faites de chaque élément configurable quelque chose que vous pouvez définir, vérifier et puis utilisez de manière appropriée dans votre script.

Par exemple, j'ai une version Java ciblée WebLogic basée sur Maven dont j'ai hérité chez mon nouvel employeur. Le script de construction est connu pour être fragile, et un autre nouvel employé et moi avons passé trois semaines (pas à plein temps, juste ici et là, mais encore de nombreuses heures) à le faire fonctionner sur nos machines. Une étape essentielle a été de prendre le contrôle du PATH afin de savoir exactement quel Java, quel Maven et quel WebLogic était appelé. J'ai créé des variables d'environnement pour pointer vers chacun de ces outils, puis j'ai calculé le PATH en fonction de ceux-ci et de quelques autres. Des techniques similaires ont apprivoisé les autres paramètres configurables, jusqu'à ce que nous ayons finalement créé une version reproductible.

Au fait, n'utilisez pas Maven, Java est correct, et n'achetez WebLogic que si vous avez absolument besoin de son clustering (mais sinon non, et surtout pas de ses fonctionnalités propriétaires).

Meilleurs vœux.

Comme avec @litb, j'ai répondu à la question " Comment manipuler les éléments $ PATH dans les scripts shell ", donc ma réponse principale est là.

La fonctionnalité «fractionnée» dans bashet d'autres dérivés du Bourne shell est obtenue de la manière la plus nette avec $IFSle séparateur inter-champs. Par exemple, pour définir les arguments de position ( $1, $2, ...) aux éléments de PATH, utilisez:

set -- $(IFS=":"; echo "$PATH")

Cela fonctionnera bien tant qu'il n'y aura pas d'espace dans $ PATH. Le faire fonctionner pour les éléments de chemin contenant des espaces est un exercice non trivial - laissé pour le lecteur intéressé. Il est probablement plus simple de le gérer en utilisant un langage de script tel que Perl.

J'ai aussi un script, clnpathque j'utilise beaucoup pour définir mon PATH. Je l'ai documenté dans la réponse à " Comment éviter de dupliquer la variable PATH dans csh ".

Ce qui rend ce problème ennuyeux, ce sont les cas de clôture parmi les premier et dernier éléments. Le problème peut être résolu avec élégance en changeant IFS et en utilisant un tableau, mais je ne sais pas comment réintroduire les deux points une fois que le chemin est converti en tableau.

Voici une version légèrement moins élégante qui supprime un répertoire de l' $PATHutilisation de la manipulation de chaînes uniquement. Je l'ai testé.

#!/bin/bash
#
#   remove_from_path dirname
#
#   removes $1 from user's $PATH

if [ $# -ne 1 ]; then
  echo "Usage: $0 pathname" 1>&2; exit 1;
fi

delendum="$1"
NEWPATH=
xxx="$IFS"
IFS=":"
for i in $PATH ; do
  IFS="$xxx"
  case "$i" in
    "$delendum") ;; # do nothing
    *) [ -z "$NEWPATH" ] && NEWPATH="$i" || NEWPATH="$NEWPATH:$i" ;;
  esac
done

PATH="$NEWPATH"
echo "$PATH"

Voici un one-liner Perl:

PATH=`perl -e '$a=shift;$_=$ENV{PATH};s#:$a(:)|^$a:|:$a$#$1#;print' /home/usr/bin`

La $avariable obtient le chemin à supprimer. Les commandes s(substitut) et printopèrent implicitement sur la $_variable.

Bon truc ici. J'utilise celui-ci pour éviter d'ajouter des dupes en premier lieu.

#!/bin/bash
#
######################################################################################
#
# Allows a list of additions to PATH with no dupes
# 
# Patch code below into your $HOME/.bashrc file or where it
# will be seen at login.
#
# Can also be made executable and run as-is.
#
######################################################################################

# add2path=($HOME/bin .)                  ## uncomment space separated list 
if [ $add2path ]; then                    ## skip if list empty or commented out
for nodup in ${add2path[*]}
do
    case $PATH in                 ## case block thanks to MIKE511
    $nodup:* | *:$nodup:* | *:$nodup ) ;;    ## if found, do nothing
    *) PATH=$PATH:$nodup          ## else, add it to end of PATH or
    esac                          ## *) PATH=$nodup:$PATH   prepend to front
done
export PATH
fi
## debug add2path
echo
echo " PATH == $PATH"
echo

Avec le globbing étendu activé, il est possible d'effectuer les opérations suivantes:

# delete all /opt/local paths in PATH
shopt -s extglob 
printf "%s\n" "${PATH}" | tr ':' '\n' | nl
printf "%s\n" "${PATH//+(\/opt\/local\/)+([^:])?(:)/}" | tr ':' '\n' | nl 

man bash | less -p extglob

Un-liner globbing étendu (enfin, en quelque sorte):

path_remove ()  { shopt -s extglob; PATH="${PATH//+(${1})+([^:])?(:)/}"; export PATH="${PATH%:}"; shopt -u extglob; return 0; } 

Il ne semble pas nécessaire d'échapper aux barres obliques dans $ 1.

path_remove ()  { shopt -s extglob; declare escArg="${1//\//\\/}"; PATH="${PATH//+(${escArg})+([^:])?(:)/}"; export PATH="${PATH%:}"; shopt -u extglob; return 0; } 

En ajoutant des deux points à PATH, nous pourrions également faire quelque chose comme:

path_remove ()  { 
   declare i newPATH
   # put a colon at the beginning & end AND double each colon in-between
   newPATH=":${PATH//:/::}:"   
   for ((i=1; i<=${#@}; i++)); do
       #echo ${@:${i}:1}
       newPATH="${newPATH//:${@:${i}:1}:/}"   # s/:\/fullpath://g
   done
   newPATH="${newPATH//::/:}"
   newPATH="${newPATH#:}"      # remove leading colon
   newPATH="${newPATH%:}"      # remove trailing colon
   unset PATH 
   PATH="${newPATH}" 
   export PATH
   return 0 
} 


path_remove_all ()  {
   declare i newPATH extglobVar
   extglobVar=0
   # enable extended globbing if necessary
   [[ ! $(shopt -q extglob) ]]  && { shopt -s extglob; extglobVar=1; }
   newPATH=":${PATH}:"
   for ((i=1; i<=${#@}; i++ )); do
      newPATH="${newPATH//:+(${@:${i}:1})*([^:])/}"     # s/:\/path[^:]*//g
   done
   newPATH="${newPATH#:}"      # remove leading colon
   newPATH="${newPATH%:}"      # remove trailing colon
   # disable extended globbing if it was enabled in this function
   [[ $extglobVar -eq 1 ]] && shopt -u extglob
   unset PATH 
   PATH="${newPATH}" 
   export PATH
   return 0 
} 

path_remove /opt/local/bin /usr/local/bin

path_remove_all /opt/local /usr/local 

Dans path_remove_all (par proxxy):

-newPATH="${newPATH//:+(${@:${i}:1})*([^:])/}" 
+newPATH="${newPATH//:${@:${i}:1}*([^:])/}"        # s/:\/path[^:]*//g 

Bien que ce soit un fil très ancien, j'ai pensé que cette solution pourrait être intéressante:

PATH="/usr/lib/ccache:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games"
REMOVE="ccache" # whole or part of a path :)
export PATH=$(IFS=':';p=($PATH);unset IFS;p=(${p[@]%%$REMOVE});IFS=':';echo "${p[*]}";unset IFS)
echo $PATH # outputs /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games

trouvé sur ce billet de blog . Je pense que j'aime le plus celui-ci :)

J'ai adopté une approche légèrement différente de celle de la plupart des gens ici et je me suis concentré spécifiquement sur la manipulation des cordes, comme ceci:

path_remove () {
    if [[ ":$PATH:" == *":$1:"* ]]; then
        local dirs=":$PATH:"
        dirs=${dirs/:$1:/:}
        export PATH="$(__path_clean $dirs)"
    fi
}
__path_clean () {
    local dirs=${1%?}
    echo ${dirs#?}
}

Ce qui précède est un exemple simplifié des fonctions finales que j'utilise. J'ai également créé path_add_beforeet path_add_aftervous permet d'insérer un chemin avant / après un chemin spécifié déjà dans PATH.

L'ensemble complet des fonctions est disponible dans path_helpers.sh dans mes dotfiles . Ils prennent entièrement en charge la suppression / l'ajout / l'ajout / l'insertion au début / au milieu / à la fin de la chaîne PATH.