Remova caminhos redundantes da variável $ PATH

Eu defini o mesmo caminho na variável $ PATH 6 vezes.

Eu não estava saindo para verificar se funcionava.

Como posso remover as duplicatas?

A variável $ PATH se parece com isso:

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

Como eu redefini-lo para apenas

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

Você acabou de executar:

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

isso seria para a sessão atual, se você quiser alterá-lo permanentemente, adicione-o a qualquer perfil .bashrc, bash.bashrc, / etc / profile - o que for adequado ao seu sistema e às necessidades do usuário.

Nota: Isto é para Linux. Vamos deixar isso claro para novos codificadores. (`, ') Não tente SET = estes.

Se você estiver usando o Bash, também poderá fazer o seguinte se, digamos, você desejar remover o diretório /home/wrong/dir/da sua PATHvariável:

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

Linux: remova caminhos redundantes da variável $ PATH

O Linux From Scratch possui esta função em / 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"
}

Isso deve ser usado com essas funções para adicionar ao caminho, para que você não faça isso de forma redundante:

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

O uso simples é fornecer apenas pathremoveo caminho do diretório a ser removido - mas lembre-se de que ele deve corresponder exatamente:

$ pathremove /home/username/anaconda3/bin

Isso removerá cada instância desse diretório do seu caminho.

Se você deseja que o diretório esteja no seu caminho, mas sem as redundâncias, você pode apenas usar uma das outras funções, por exemplo - para o seu caso específico:

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

Mas, a menos que a legibilidade seja a preocupação, neste momento é melhor você apenas fazer:

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

Isso funcionaria em todas as conchas conhecidas pelo homem?

Eu presumo que o acima para o trabalho na sh, dashe, bashpelo menos. Eu ficaria surpreso ao saber que não funciona csh,fish', or ksh`. Duvido que funcionaria no shell de comando do Windows ou no Powershell.

Se você possui o Python, o seguinte tipo de comando deve fazer o que é solicitado diretamente (ou seja, remover caminhos redundantes):

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

Um one-liner (para evitar problemas de múltiplas linhas):

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

O acima remove os caminhos redundantes posteriores. Para remover caminhos redundantes anteriores, use o índice de uma lista invertida e inverta-o novamente:

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

Aqui está um código de uma linha que limpa o PATH

• Não perturba a ordem do PATH, apenas remove duplicatas
• Guloseimas: e o PATH graciosamente
• Nenhum caractere especial usado, portanto, não requer escape

• Usa /bin/awkpara que funcione mesmo quando PATH está quebrado

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

1. Somente echo $PATH
2. copiar detalhes em um editor de texto
3. remover entradas indesejadas
4. PATH= # pass new list of entries

Se você deseja remover todos os caminhos duplicados, eu uso este script que escrevi há algum tempo, pois estava tendo problemas com vários caminhos 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"

E eu coloquei no meu ~ / .profile no final. Desde que eu uso o BASH quase exclusivamente, eu não tentei em outros reservatórios.

Supondo que seu shell seja o Bash, você pode definir o caminho com

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

mas, como Levon disse em outra resposta, assim que você encerrar o shell, as alterações desaparecerão. Você provavelmente deseja configurar seu PATHin ~/.bash_profileou ~/.bashrc.

No bash, você pode simplesmente $ {var / find / replace}

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

Ou, neste caso (como o bit de substituição está vazio), basta:

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

Eu vim aqui primeiro, mas fui outra mercadoria, pois pensei que haveria uma expansão de parâmetros para fazer isso. Mais fácil que o sed !.

Como substituir o caractere de marcador ou palavra na variável pelo valor de outra variável no Bash?

Não há ferramentas padrão para "editar" o valor de $PATH (por exemplo, "adicionar pasta apenas quando ainda não existe" ou "remover esta pasta").

Para verificar qual seria o caminho ao fazer login na próxima vez, use telnet localhost(outelnet 127.0.0.1 ). Ele solicitará seu nome de usuário e senha.

Isso fornece um novo shell de login (ou seja, um completamente novo que não herda nada do ambiente atual).

Você pode verificar o valor de $PATHlá e editar seus arquivos rc até que esteja correto. Isso também é útil para verificar se você pode efetuar login novamente após fazer uma alteração em um arquivo importante.

Como você adicionou esses caminhos duplicados à sua variável PATH? Você deve ter editado um dos seus .arquivos. ( .tcshrc, ou.bashrc etc, dependendo do seu sistema / shell). A maneira de corrigi-lo é editar o arquivo novamente e remover os caminhos duplicados.

Se você não editou nenhum arquivo e deve ter modificado o PATH interativamente. Nesse caso, as alterações não serão "mantidas", ou seja, se você abrir outro shell ou se desconectar e se conectar novamente, as alterações desaparecerão automaticamente.

Observe que também existem alguns arquivos de configuração em todo o sistema, mas é improvável que você os modifique; portanto, provavelmente você alterará os arquivos no diretório pessoal pessoal (se desejar tornar essas alterações permanentes depois de definir um conjunto de caminhos)

Para um modelo fácil de copiar e colar, eu uso este snippet Perl:

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

Dessa forma, você não precisa escapar das barras para o operador substituto.