Uma maneira mais confortável de editar um longo $ PATH?

Quero adicionar, em ~ / .bashrc, alguns diretórios ao meu $ PATH.

Meu $ PATH é bastante longo, portanto é um pouco difícil ver quais diretórios ele contém e em que ordem.

Eu sei que posso modificar meu ~ / .bashrc para:

PATH=$PATH:/some/dir
PATH=$PATH:/another/dir:/yet/another
PATH=$PATH:/and/another
...

facilitaria a leitura. Mas eu queria saber se, durante os últimos anos, o Bash adquiriu alguma sintaxe que facilita a especificação de um longo caminho. Por exemplo, estou fantasiando sobre uma sintaxe semelhante a:

PATH=:((
  /some/dir
  /another/dir
  /yet/another
  /and/another
  ...
))

Eu sei que essa sintaxe é inválida. Fiquei me perguntando se há algo tão fácil. Existe?

Eu uso um conjunto de funções de conveniência para acrescentar ou acrescentar um caminho a uma variável. As funções vêm no pacote de distribuição do Bash em um arquivo de contribuição chamado "pathfuncs".

• add_path adicionará a entrada ao final da variável PATH
• pre_path adicionará a entrada ao início da variável PATH
• del_path removerá a entrada da variável PATH, onde quer que esteja

Se você especificar uma variável como o segundo argumento, ela será usada em vez de PATH.

Por conveniência, aqui estão eles:

# 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;:\$;;"`
}

Se você os adicionar ao seu arquivo de inicialização do bash, poderá adicioná-lo ao PATH assim:

pre_path $HOME/bin
add_path /sbin
add_path /usr/sbin

Ou especifique uma variável diferente:

pre_path $HOME/man MANPATH
pre_path $HOME/share/man MANPATH
add_path /usr/local/man MANPATH
add_path /usr/share/man MANPATH

Eu uso esse método nos meus arquivos rc colocando os pre_paths primeiro e os add_paths segundo. Isso facilita a compreensão de todas as alterações no meu caminho. Outro benefício é que as linhas são curtas o suficiente para que eu possa adicionar um comentário à linha, se necessário.

E como essas são funções, você pode usá-las interativamente a partir da linha de comando, como dizendo add_path $(pwd)para adicionar o diretório atual ao caminho.

OK, descobri a seguinte solução, que acho elegante (no que diz respeito à sintaxe do shell). Ele usa a sintaxe de matriz do Bash e também uma maneira elegante de juntar elementos:

paths=(
  /some/dir
  /another/dir
  '/another/dir with spaces in it'
  /yet/another
  /and/another
  /end
)
paths_joined=$( IFS=: ; echo "${paths[*]}" )

PATH=$paths_joined:$PATH

ALERTA!

Acontece que esta solução tem um problema : Ao contrário das soluções @terdon e @Starfish, ela não verifica primeiro se os caminhos já estão no PATH. Então, como eu quero colocar esse código em ~ / .bashrc (e não em ~ / .profile), caminhos duplicados aparecerão no PATH. Portanto, não use esta solução (a menos que você a coloque em ~ / .profile (ou, melhor, ~ / .bash_profile, pois possui sintaxe específica do Bash)).

Eu uso a função abaixo no meu ~/.bashrc. É algo que recebi de um administrador de sistemas no meu antigo laboratório, mas acho que ele não escreveu. Basta adicionar essas linhas ao seu ~/.profileou ~/.bashrc:

pathmunge () {
        if ! echo $PATH | /bin/grep -Eq "(^|:)$1($|:)" ; then
           if [ "$2" = "after" ] ; then
              PATH=$PATH:$1
           else
              PATH=$1:$PATH
           fi
        fi
}

Isso tem várias vantagens:

• Adicionando novos diretórios para o $PATHtrivial: pathmunge /foo/bar;
• Evita entradas duplicadas;
• Você pode optar por adicionar uma nova entrada ao início ( pathmunge /foo/barou ao final ( pathmunge /foo/bardepois) do) $PATH.

O arquivo de inicialização do seu shell conteria algo como:

pathmunge /some/dir
pathmunge /another/dir
pathmunge '/another/dir with spaces in it'
pathmunge /yet/another
pathmunge /and/another
pathmunge /end

Quero adicionar, em ~ / .bashrc, alguns diretórios ao meu $ PATH.

Eu uso o seguinte no Cygwin. Deve funcionar em outras versões do bash. Você pode remover a unset PATHversão atual PATH(se você fizer isso, talvez precise descobrir como adicionar os :separadores corretamente).

Nota:

• Uma vez eu tive essa funcionalidade em uma bashfunção, mas a perdi após uma falha no disco.

No meu .bash_profile:

# Build up the path using the directories in ~/.path_elements
unset PATH
while read line; do 
  PATH="${PATH}$line"; 
done < ~/.path_elements

...

# Add current directory to path
export PATH=".:${PATH}"

Em ~/.path_elements:

/home/DavidPostill/bin:
/usr/local/bin:
/usr/bin:
/c/Windows/system32:
/c/Windows

Eu uso isso no meu .bashrc (e também no meu .zshrc, pois normalmente uso o zsh quando disponível, em vez do bash). É verdade que exige que eu adicione diretórios manualmente, mas uma vantagem é que, à medida que o atualizo, posso copiá-lo para novos servidores e não me preocupar com o PATH em um novo servidor criado com diretórios que não existem lá.

##
## CAMINHO
##
## Em vez de apenas atrapalhar nosso PATH com diretórios que podem
## não for apropriado para este servidor, tente ser inteligente sobre o que adicionamos
##
PATH = / usr / local / sbin: / usr / local / bin: / usr / sbin: / usr / bin: / sbin: / bin
[-d / cs / sbin] && PATH = / cs / sbin: $ PATH
[-d / cs / bin] && PATH = / cs / bin: $ PATH
[-d / usr / ucb] && PATH = $ PATH: / usr / ucb
[-d / usr / ccs / bin] && PATH = $ PATH: / usr / ccs / bin
[-d / usr / local / ssl / bin] && PATH = $ PATH: / usr / local / ssl / bin
[-d / usr / krb5 / bin] && PATH = $ PATH: / usr / krb5 / bin
[-d / usr / krb5 / sbin] && PATH = $ PATH: / usr / krb5 / sbin
[-d / usr / kerberos / sbin] && PATH = $ PATH: / usr / kerberos / sbin
[-d / usr / kerberos / bin] && PATH = $ PATH: / usr / kerberos / bin
[-d /cs/local/jdk1.5.0/bin] && PATH = $ PATH: /cs/local/jdk1.5.0/bin
[-d /usr/java/jre1.5.0_02/bin] && PATH = $ PATH: /usr/java/jre1.5.0_02/man
[-d /usr/java1.2/bin] && PATH = $ PATH: /usr/java1.2/bin
[-d /cs/local/perl5.8.0/bin] && PATH = $ PATH: /cs/local/perl5.8.0/bin
[-d / usr / perl5 / bin] && PATH = $ PATH: / usr / perl5 / bin
[-d / usr / X11R6 / bin] && PATH = $ PATH: / usr / X11R6 / bin
[-d / etc / X11] && PATH = $ PATH: / etc / X11
[-d / opt / sfw / bin] && PATH = $ PATH: / opt / sfw / bin
[-d / usr / local / apache / bin] && PATH = $ PATH: / usr / local / apache / bin
[-d / usr / apache / bin] && PATH = $ PATH: / usr / apache / bin
[-d / cs / admin / bin] && PATH = $ PATH: / cs / admin / bin
[-d / usr / openwin / bin] && PATH = $ PATH: / usr / openwin / bin
[-d / usr / xpg4 / bin] && PATH = $ PATH: / usr / xpg4 / bin
[-d / usr / dt / bin] && PATH = $ PATH: / usr / dt / bin

Eu faço o mesmo pelo meu MANPATH:

##
## MANPATH
##
## Em vez de apenas encher nosso MANPATH com diretórios que podem
## não for apropriado para este servidor, tente ser inteligente sobre o que adicionamos
##
MANPATH = / usr / local / man
[-d / usr / share / man] && MANPATH = $ MANPATH: / usr / share / man
[-d / usr / local / compartilhamento / homem] && MANPATH = $ MANPATH: / usr / local / compartilhamento / homem
[-d / usr / man] && MANPATH = $ MANPATH: / usr / man
[-d / cs / man] && MANPATH = $ MANPATH: / cs / man
[-d / usr / krb5 / man] && MANPATH = $ MANPATH: / usr / krb5 / man
[-d / usr / kerberos / man] && MANPATH = $ MANPATH: / usr / kerberos / man
[-d / usr / local / ssl / man] && MANPATH = $ MANPATH: / usr / local / ssl / man
[-d /cs/local/jdk1.5.0/man] && MANPATH = $ MANPATH: /cs/local/jdk1.5.0/man
[-d /usr/java/jre1.5.0_02/man] && MANPATH = $ MANPATH: /usr/java/jre1.5.0_02/man
[-d /usr/java1.2/man] && MANPATH = $ MANPATH: /usr/java1.2/man
[-d / usr / X11R6 / man] && MANPATH = $ MANPATH: / usr / X11R6 / man
[-d / usr / local / apache / man] && MANPATH = $ MANPATH: / usr / local / apache / man
[-d / usr / local / mysql / man] && MANPATH = $ MANPATH: / usr / local / mysql / man
[-d /cs/local/perl5.8.0/man] && MANPATH = $ MANPATH: /cs/local/perl5.8.0/man
[-d / usr / perl5 / man] && MANPATH = $ MANPATH: / usr / perl5 / man
[-d / usr / local / perl / man] && MANPATH = $ MANPATH: / usr / local / perl / man
[-d /usr/local/perl5.8.0/man] && MANPATH = $ MANPATH: /usr/local/perl5.8.0/man
[-d / usr / openwin / man] && MANPATH = $ MANPATH: / usr / openwin / man

Além de ter um único arquivo que eu posso copiar para sistemas em ambientes diferentes, sem medo de adicionar diretórios inexistentes ao PATH, essa abordagem também tem a vantagem de permitir que eu especifique a ordem em que os diretórios devem aparecer no PATH. Como a primeira linha de cada definição redefine completamente a variável PATH, eu posso atualizar meu .bashrc e originar após a edição para atualizar meu shell sem adicionar entradas duplicadas (que eu costumava experimentar há muito tempo quando simplesmente comecei com " $ PATH = $ PATH: / new / dir ". Isso garante que eu receba uma cópia limpa na ordem que desejar.

Existe uma maneira fácil! Leia Funções de Shell e Variáveis ​​de Caminho no Linux Journal , 01 de março de 2000 Por Stephen Collyer

As funções permitem-me usar um novo tipo de dados no meu ambiente bash - a lista separada por dois pontos. Além do PATH, eu os uso para ajustar meu LOCATE_PATH, MANPATH e outros, e como um tipo de dados geral na programação do bash. Aqui está como eu configuro meu PATH (usando as funções):

# Add my bin directory to $PATH at the beginning, so it overrides 
addpath -f -p PATH $HOME/bin

# For Raspberry Pi development (add at end)
addpath -b -p PATH ${HOME}/rpi/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian-x64/bin

# remove nonexistent directories from PATH
delpath -n -p PATH

# ensure PATH contains unique entries
uniqpath -p PATH

Como o link do Linux Journal é chamado de "quebrado", coloquei as Funções do caminho Bash em um arquivo .shar em http://pastebin.ubuntu.com/13299528/