Supprimer les chemins redondants de la variable $ PATH

J'ai défini le même chemin dans la variable $ PATH 6 fois.

Je ne me déconnectais pas pour vérifier si cela fonctionnait.

Comment puis-je supprimer les doublons?

La variable $ PATH ressemble à ceci:

echo $PATH

/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/home/flacs/Programmes/USFOS/bin:/home/flacs/Programmes/USFOS/bin:/home/flacs/Programmes/USFOS/bin:/home/flacs/Programmes/USFOS/bin:/home/flacs/Programmes/USFOS/bin:/home/flacs/Programmes/USFOS/bin

Comment pourrais-je le réinitialiser à juste

/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games

Vous exécutez simplement:

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

ce serait pour la session en cours, si vous voulez changer de façon permanente, ajoutez-le à n'importe quel .bashrc, bash.bashrc, / etc / profile - tout ce qui convient à votre système et aux besoins de l'utilisateur.

Remarque: ceci est pour Linux. Nous allons clarifier cela pour les nouveaux codeurs. (`, ') N'essayez pas de SET = ces.

Si vous utilisez Bash, vous pouvez également effectuer les opérations suivantes si, disons, vous souhaitez supprimer le répertoire /home/wrong/dir/de votre PATHvariable:

PATH=`echo $PATH | sed -e 's/:\/home\/wrong\/dir\/$//'`

Linux: supprimer les chemins redondants de la variable $ PATH

Linux From Scratch a cette fonction 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"
}

Ceci est destiné à être utilisé avec ces fonctions pour ajouter au chemin, afin de ne pas le faire de manière redondante:

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"
}

L'utilisation simple consiste simplement à donner pathremovele chemin du répertoire à supprimer - mais gardez à l'esprit qu'il doit correspondre exactement:

$ pathremove /home/username/anaconda3/bin

Cela supprimera chaque instance de ce répertoire de votre chemin.

Si vous voulez le répertoire dans votre chemin, mais sans les redondances, vous pouvez simplement utiliser l'une des autres fonctions, par exemple - pour votre cas spécifique:

$ pathprepend /usr/local/sbin
$ pathappend /usr/local/bin
$ pathappend /usr/sbin
$ pathappend /usr/bin
$ pathappend /sbin
$ pathappend /bin
$ pathappend /usr/games

Mais, à moins que la lisibilité ne soit le problème, à ce stade, vous feriez mieux de simplement faire:

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

Est-ce que ce qui précède fonctionnerait dans toutes les coquilles connues de l'homme?

Je présume ci - dessus au travail sh, dashet bashau moins. Je serais surpris d'apprendre que cela ne fonctionne pas dans csh, fish', orksh`. Je doute que cela fonctionne dans le shell de commande Windows ou Powershell.

Si vous avez Python, le type de commande suivant devrait faire ce qui est directement demandé (c'est-à-dire supprimer les chemins redondants):

$ PATH=$( python -c "
import os
path = os.environ['PATH'].split(':')
print(':'.join(sorted(set(path), key=path.index)))
" )

Une ligne unique (pour éviter les problèmes multilignes):

$ PATH=$( python -c "import os; path = os.environ['PATH'].split(':'); print(':'.join(sorted(set(path), key=path.index)))" )

Ce qui précède supprime les chemins redondants ultérieurs. Pour supprimer les chemins redondants antérieurs, utilisez l'index d'une liste inversée et inversez-le à nouveau:

$ PATH=$( python -c "
import os
path = os.environ['PATH'].split(':')[::-1]
print(':'.join(sorted(set(path), key=path.index, reverse=True)))
" )

Voici un code d'une ligne qui nettoie le CHEMIN

• Cela ne perturbe pas l'ordre du PATH, supprime simplement les doublons
• Traite: et empth PATH gracieusement
• Aucun caractère spécial utilisé, donc ne nécessite pas d'échappement

• Utilise /bin/awkpour que cela fonctionne même lorsque PATH est cassé

  export PATH="$(echo "$PATH" |/bin/awk 'BEGIN{RS=":";}
  {sub(sprintf("%c$",10),"");if(A[$0]){}else{A[$0]=1;
  printf(((NR==1)?"":":")$0)}}')";

1. Juste echo $PATH
2. copier les détails dans un éditeur de texte
3. supprimer les entrées indésirables
4. PATH= # pass new list of entries

Si vous souhaitez simplement supprimer les chemins en double, j'utilise ce script que j'ai écrit il y a quelque temps car j'avais des problèmes avec plusieurs chemins perl5 / bin:

#!/bin/bash
#
# path-cleanup
#
# This must be run as "source path-cleanup" or ". path-cleanup"
# so the current shell gets the changes.

pathlist=`echo $PATH | sed 's/:/\n/g' | uniq`

# echo "Starting PATH: $PATH"
# echo "pathlist: $pathlist"
unset PATH
# echo "After unset, PATH: $PATH"
for dir in $pathlist
do
    if test -d $dir ; then
        if test -z $PATH; then
            PATH=$dir
        else
            PATH=$PATH:$dir
        fi
    fi
done
export PATH
# echo "After loop, PATH: $PATH"

Et je l'ai mis dans mon ~ / .profile à la fin. Depuis que j'utilise BASH presque exclusivement, je ne l'ai pas essayé dans d'autres shells.

En supposant que votre shell est Bash, vous pouvez définir le chemin avec

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

mais comme Levon l'a dit dans une autre réponse, dès que vous terminerez le shell, les changements disparaîtront. Vous souhaitez probablement configurer votre PATHin ~/.bash_profileou ~/.bashrc.

Dans bash, vous pouvez simplement $ {var / find / replace}

PATH=${PATH/%:\/home\/wrong\/dir\//}

Ou dans ce cas (car le bit de remplacement est vide) simplement:

PATH=${PATH%:\/home\/wrong\/dir\/}

Je suis venu ici en premier, mais je suis allé ailleurs car je pensais qu'il y aurait une expansion des paramètres pour le faire. Plus facile que sed !.

Comment remplacer un caractère ou un mot d'espace réservé dans une variable par la valeur d'une autre variable dans Bash?

Il n’existe pas d’outils standard pour «modifier» la valeur de $PATH (c'est-à-dire "ajouter un dossier uniquement quand il n'existe pas déjà" ou "supprimer ce dossier").

Pour vérifier quel serait le chemin lors de votre prochaine connexion, utilisez telnet localhost(outelnet 127.0.0.1 ). Il vous demandera ensuite votre nom d'utilisateur et votre mot de passe.

Cela vous donne un nouveau shell de connexion (c'est-à-dire un tout nouveau qui n'hérite de rien de l'environnement actuel).

Vous pouvez vérifier la valeur de $PATHlà et modifier vos fichiers rc jusqu'à ce qu'il soit correct. Ceci est également utile pour voir si vous pouvez vous reconnecter après avoir modifié un fichier important.

Comment avez-vous ajouté ces chemins en double à votre variable PATH? Vous devez avoir édité l'un de vos .fichiers. ( .tcshrcou.bashrc , etc. en fonction de votre système / shell particulier). La façon de résoudre ce problème est de modifier à nouveau le fichier et de supprimer les chemins en double.

Si vous n'avez modifié aucun fichier et que vous devez avoir modifié le PATH de manière interactive. Dans ce cas, les modifications ne "colleront" pas, c'est-à-dire que si vous ouvrez un autre shell, ou si vous vous déconnectez et vous reconnectez, les modifications disparaîtront automatiquement.

Notez qu'il existe également des fichiers de configuration à l'échelle du système, mais il est peu probable que vous les ayez modifiés, il est donc fort probable que vous changiez des fichiers dans votre répertoire personnel (si vous souhaitez rendre ces modifications permanentes une fois que vous vous êtes installé sur un ensemble de chemins)

Pour un modèle de copier-coller facile, j'utilise cet extrait de code Perl:

PATH=`echo $PATH | perl -pe s:/path/to/be/excluded::`

De cette façon, vous n'avez pas besoin d'échapper aux barres obliques pour l'opérateur de substitution.