Adicione o diretório a $ PATH se ele ainda não estiver lá

Alguém escreveu uma função bash para adicionar um diretório ao $ PATH apenas se ele ainda não estiver lá?

Eu normalmente adiciono ao PATH usando algo como:

export PATH=/usr/local/mysql/bin:$PATH

Se eu construir meu PATH em .bash_profile, ele não será lido, a menos que a sessão em que eu participe seja uma sessão de logon - o que nem sempre é verdade. Se eu construir meu PATH no .bashrc, ele será executado com cada subshell. Portanto, se eu iniciar uma janela do Terminal e, em seguida, executar a tela e, em seguida, executar um script de shell, obtenho:

$ echo $PATH
/usr/local/mysql/bin:/usr/local/mysql/bin:/usr/local/mysql/bin:....

Vou tentar criar uma função bash chamada add_to_path()que apenas adiciona o diretório se ele não estiver lá. Mas, se alguém já escreveu (ou encontrou) uma coisa dessas, não vou dedicar tempo a isso.

Do meu .bashrc:

pathadd() {
    if [ -d "$1" ] && [[ ":$PATH:" != *":$1:"* ]]; then
        PATH="${PATH:+"$PATH:"}$1"
    fi
}

Observe que PATH já deve estar marcado como exportado, portanto, a reexportação não é necessária. Isso verifica se o diretório existe e é um diretório antes de adicioná-lo, com o qual você pode não se importar.

Além disso, isso adiciona o novo diretório ao final do caminho; para colocar no início, use em PATH="$1${PATH:+":$PATH"}"vez da PATH=linha acima .

Expandindo a resposta de Gordon Davisson, isso suporta vários argumentos

pathappend() {
  for ARG in "$@"
  do
    if [ -d "$ARG" ] && [[ ":$PATH:" != *":$ARG:"* ]]; then
        PATH="${PATH:+"$PATH:"}$ARG"
    fi
  done
}

Assim, você pode fazer o caminho: path1 path2 path3 ...

Para anexar,

pathprepend() {
  for ((i=$#; i>0; i--)); 
  do
    ARG=${!i}
    if [ -d "$ARG" ] && [[ ":$PATH:" != *":$ARG:"* ]]; then
        PATH="$ARG${PATH:+":$PATH"}"
    fi
  done
}

Semelhante ao pathappend, você pode fazer

pathprepend path1 path2 path3 ...

Aqui está algo da minha resposta a esta pergunta combinada com a estrutura da função de Doug Harris. Ele usa expressões regulares do Bash:

add_to_path ()
{
    if [[ "$PATH" =~ (^|:)"${1}"(:|$) ]]
    then
        return 0
    fi
    export PATH=${1}:$PATH
}

Coloque isso nos comentários da resposta selecionada, mas os comentários parecem não suportar a formatação PRE, portanto adicione a resposta aqui:

@ gordon-davisson Eu não sou um grande fã de citações e concatenações desnecessárias. Supondo que você esteja usando uma versão do bash> = 3, você pode usar regexs integrados do bash e fazer:

pathadd() {
    if [ -d "$1" ] && [[ ! $PATH =~ (^|:)$1(:|$) ]]; then
        PATH+=:$1
    fi
}

Isso manipula corretamente os casos em que há espaços no diretório ou no PATH. Há alguma dúvida sobre se o mecanismo de regex do bash é lento o suficiente para que isso possa ser menos eficiente do que a concatenação e interpolação de strings que sua versão faz, mas de alguma forma parece mais esteticamente limpo para mim.

idempotent_path_prepend ()
{
    PATH=${PATH//":$1"/} #delete any instances in the middle or at the end
    PATH=${PATH//"$1:"/} #delete any instances at the beginning
    export PATH="$1:$PATH" #prepend to beginning
}

Quando você precisar que $ HOME / bin apareça exatamente uma vez no início do seu $ PATH e em nenhum outro lugar, não aceite substitutos.

Aqui está uma solução alternativa que tem a vantagem adicional de remover entradas redundantes:

function pathadd {
    PATH=:$PATH
    PATH=$1${PATH//:$1/}
}

O argumento único para essa função é anexado ao PATH e a primeira instância da mesma sequência é removida do caminho existente. Em outras palavras, se o diretório já existir no caminho, ele será promovido para a frente em vez de adicionado como duplicado.

A função funciona adicionando dois pontos ao caminho para garantir que todas as entradas tenham dois pontos à frente e, em seguida, acrescentando a nova entrada ao caminho existente com a entrada removida. A última parte é executada usando a ${var//pattern/sub}notação do bash ; veja o manual do bash para mais detalhes.

Aqui está o meu (acredito que foi escrito anos atrás por Oscar, o administrador de sistemas do meu antigo laboratório, tudo creditado a ele), está no meu bashrc há séculos. Ele tem o benefício adicional de permitir que você acrescente ou anexe o novo diretório conforme desejado:

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

Uso:

$ echo $PATH
/bin/:/usr/local/bin/:/usr/bin
$ pathmunge /bin/
$ echo $PATH
/bin/:/usr/local/bin/:/usr/bin
$ pathmunge /sbin/ after
$ echo $PATH
/bin/:/usr/local/bin/:/usr/bin:/sbin/

Para anexar, eu gosto da solução de Russell, mas há um pequeno erro: se você tentar anexar algo como "/ bin" a um caminho de "/ sbin: / usr / bin: / var / usr / bin: / usr / local / bin: / usr / sbin "substitui" / bin: "3 vezes (quando realmente não correspondia). Combinando uma correção para isso com a solução anexa de @ gordon-davisson, recebo o seguinte:

path_prepend() {
    if [ -d "$1" ]; then
        PATH=${PATH//":$1:"/:} #delete all instances in the middle
        PATH=${PATH/%":$1"/} #delete any instance at the end
        PATH=${PATH/#"$1:"/} #delete any instance at the beginning
        PATH="$1${PATH:+":$PATH"}" #prepend $1 or if $PATH is empty set to $1
    fi
}

Um alias simples como este abaixo deve fazer o truque:

alias checkInPath="echo $PATH | tr ':' '\n' | grep -x -c "

Tudo o que faz é dividir o caminho no caractere: e comparar cada componente com o argumento que você passa. O grep verifica se há uma correspondência completa de linhas e imprime a contagem.

Uso da amostra:

$ checkInPath "/usr/local"
1
$ checkInPath "/usr/local/sbin"
1
$ checkInPath "/usr/local/sbin2"
0
$ checkInPath "/usr/local/" > /dev/null && echo "Yes" || echo "No"
No
$ checkInPath "/usr/local/bin" > /dev/null && echo "Yes" || echo "No"
Yes
$ checkInPath "/usr/local/sbin" > /dev/null && echo "Yes" || echo "No"
Yes
$ checkInPath "/usr/local/sbin2" > /dev/null && echo "Yes" || echo "No"
No

Substitua o comando echo por addToPath ou algum apelido / função semelhante.

Consulte Como evitar duplicar a variável de caminho no csh? no StackOverflow para obter um conjunto de respostas para esta pergunta.

Aqui está o que eu criei:

add_to_path ()
{
    path_list=`echo $PATH | tr ':' ' '`
    new_dir=$1
    for d in $path_list
    do
        if [ $d == $new_dir ]
        then
            return 0
        fi
    done
    export PATH=$new_dir:$PATH
}

Agora em .bashrc eu tenho:

add_to_path /usr/local/mysql/bin

Versão atualizada após o comentário sobre como meu original não manipula diretórios com espaços (obrigado a esta pergunta por me indicar o uso IFS):

add_to_path ()
{
    new_dir=$1
    local IFS=:
    for d in $PATH
    do
        if [[ "$d" == "$new_dir" ]]
        then
            return 0
        fi
    done
    export PATH=$new_dir:$PATH
}

Estou um pouco surpreso que ninguém tenha mencionado isso ainda, mas você pode usar readlink -fpara converter caminhos relativos em caminhos absolutos e adicioná-los ao PATH como tal.

Por exemplo, para melhorar a resposta de Guillaume Perrault-Archambault,

pathappend() {
  for ARG in "$@"
  do
    if [ -d "$ARG" ] && [[ ":$PATH:" != *":$ARG:"* ]]; then
        PATH="${PATH:+"$PATH:"}$ARG"
    fi
  done
}

torna-se

pathappend() {
    for ARG in "$@"
    do
        if [ -d "$ARG" ] && [[ ":$PATH:" != *":$ARG:"* ]]
        then
            if ARGA=$(readlink -f "$ARG")               #notice me
            then
                if [ -d "$ARGA" ] && [[ ":$PATH:" != *":$ARGA:"* ]]
                then
                    PATH="${PATH:+"$PATH:"}$ARGA"
                fi
            else
                PATH="${PATH:+"$PATH:"}$ARG"
            fi
        fi
    done
}

1. O básico - que bem isso faz?

O readlink -fcomando (entre outras coisas) converterá um caminho relativo em um caminho absoluto. Isso permite que você faça algo como

$ cd / caminho / para / meu / bin / dir
$ pathappend .
$ echo "$ PATH"
<your_old_path> : / caminho / para / meu / bin / dir

2. Por que testamos duas vezes o CAMINHO?

Bem, considere o exemplo acima. Se o usuário disser a partir do diretório uma segunda vez, será . Claro, não estará presente em . Mas, em seguida, será definido como (o equivalente caminho absoluto ), que é já . Então, precisamos evitar a adição de uma segunda vez.pathappend ./path/to/my/bin/dirARG..PATHARGA/path/to/my/bin/dir.PATH/path/to/my/bin/dirPATH

Talvez o mais importante readlinkseja que, como o nome indica , o objetivo principal é olhar para um link simbólico e ler o nome do caminho que ele contém (ou seja, aponta para). Por exemplo:

$ ls -ld /usr/lib/perl/5.14
-rwxrwxrwx  1   root   root    Sep  3  2015 /usr/lib/perl/5.14 -> 5.14.2
$ readlink /usr/lib/perl/5.14
5.14.2
$ readlink -f /usr/lib/perl/5.14
/usr/lib/perl/5.14.2

Agora, se você diz pathappend /usr/lib/perl/5.14, e você já tem /usr/lib/perl/5.14no seu CAMINHO, tudo bem; podemos simplesmente deixar como está. Mas, se /usr/lib/perl/5.14já não estiver no seu PATH, chamamos readlinke obtemos ARGA= /usr/lib/perl/5.14.2e, em seguida, adicionamos isso a PATH. Mas espere um minuto - se você já disse pathappend /usr/lib/perl/5.14, então você já tem /usr/lib/perl/5.14.2seu PATH e, novamente, precisamos verificar isso para evitar adicioná-lo a PATHuma segunda vez.

3. Qual é o problema if ARGA=$(readlink -f "$ARG")?

Caso não esteja claro, essa linha testa se o resultado readlinké bem - sucedido. Isso é apenas uma boa prática de programação defensiva. Se vamos usar a saída do comando  m como parte do comando  n (onde m  <  n ), é prudente verificar se o comando  m falhou e lidar com isso de alguma forma. Eu não acho que isso readlinkirá falhar - mas, como discutido em Como recuperar o caminho absoluto de um arquivo arbitrário do OS X e de outros lugares, readlinké uma invenção do GNU. Ele não está especificado no POSIX, portanto, sua disponibilidade no Mac OS, Solaris e outros Unixes não Linux é questionável. Na verdade, acabei de ler um comentário que diz "readlink -fparece não funcionar no Mac OS X 10.11.6, mas realpathfunciona imediatamente . ”Portanto, se você estiver em um sistema que não possui readlinkou onde readlink -fnão funciona, poderá modificá-lo script a ser usado realpath.) Ao instalar uma rede de segurança, tornamos nosso código um pouco mais portátil.

Claro, se você estiver em um sistema que não possui readlink(ou  realpath), não vai querer fazer isso .pathappend .

O segundo -dteste ( [ -d "$ARGA" ]) é realmente provavelmente desnecessário. Não consigo pensar em nenhum cenário em que $ARGum diretório seja readlinkbem - sucedido, mas  $ARGAnão seja um diretório. Apenas copiei e colei a primeira ifdeclaração para criar a terceira e deixei o  -dteste por preguiça.

4. Outros comentários?

Sim. Como muitas das outras respostas aqui, esta testa se cada argumento é um diretório, o processa se for e o ignora se não for. Isso pode (ou não) ser adequado se você estiver usando pathappend apenas .arquivos " " (como .bash_profilee .bashrc) e outros scripts. Mas, como essa resposta mostrou (acima), é perfeitamente viável usá-la interativamente. Você ficará muito confuso se fizer isso

$ pathappend /usr/local/nysql/bin
$ mysql
-bash: mysql: command not found

Você notou que eu disse nysql no pathappendcomando, em vez de mysql? E isso pathappendnão disse nada; apenas ignorou silenciosamente o argumento incorreto?

Como eu disse acima, é uma boa prática lidar com erros. Aqui está um exemplo:

pathappend() {
    for ARG in "$@"
    do
        if [ -d "$ARG" ]
        then
            if [[ ":$PATH:" != *":$ARG:"* ]]
            then
                if ARGA=$(readlink -f "$ARG")           #notice me
                then
                    if [[ ":$PATH:" != *":$ARGA:"* ]]
                    then
                        PATH="${PATH:+"$PATH:"}$ARGA"
                    fi
                else
                    PATH="${PATH:+"$PATH:"}$ARG"
                fi
            fi
        else
            printf "Error: %s is not a directory.\n" "$ARG" >&2
        fi
    done
}

function __path_add(){  
if [ -d "$1" ] ; then  
    local D=":${PATH}:";   
    [ "${D/:$1:/:}" == "$D" ] && PATH="$PATH:$1";  
    PATH="${PATH/#:/}";  
    export PATH="${PATH/%:/}";  
fi  
}  

Desta forma, funciona bem:

if [[ ":$PATH:" != *":/new-directory:"* ]]; then PATH=${PATH}:/new-directory; fi

Minhas versões são menos cuidadosas com caminhos vazios e insistindo em que os caminhos sejam válidos e diretórios do que alguns postados aqui, mas eu acho uma coleção grande de prefpend / append / clean / unique-ify / etc. funções shell para serem úteis na manipulação de caminhos. O lote inteiro, em seu estado atual, está aqui: http://pastebin.com/xS9sgQsX (feedback e melhorias muito bem-vindos!)

Você pode usar um liner perl one:

appendPaths() { # append a group of paths together, leaving out redundancies
    # use as: export PATH="$(appendPaths "$PATH" "dir1" "dir2")
    # start at the end:
    #  - join all arguments with :,
    #  - split the result on :,
    #  - pick out non-empty elements which haven't been seen and which are directories,
    #  - join with :,
    #  - print
    perl -le 'print join ":", grep /\w/ && !$seen{$_}++ && -d $_, split ":", join ":", @ARGV;' "$@"
}

Aqui está no bash:

addToPath() { 
    # inspired by Gordon Davisson, http://superuser.com/a/39995/208059
    # call as: addToPath dir1 dir2
    while (( "$#" > 0 )); do
    echo "Adding $1 to PATH."
    if [[ ! -d "$1" ]]; then
        echo "$1 is not a directory.";
    elif [[ ":$PATH:" == *":$1:"* ]]; then
        echo "$1 is already in the path."
    else
            export PATH="${PATH:+"$PATH:"}$1" # ${x:-defaultIfEmpty} ${x:+valueIfNotEmpty}
    fi
    shift
    done
}

Modifiquei levemente a resposta de Gordon Davisson para usar o dir atual, se nenhum for fornecido. Então você pode simplesmente fazer a paddpartir do diretório que deseja adicionar ao seu PATH.

padd() {
  current=`pwd`
  p=${1:-$current}
  if [ -d "$p" ] && [[ ":$PATH:" != *":$p:"* ]]; then
      PATH="$p:$PATH"
  fi
}

Você pode verificar se uma variável personalizada foi definida, caso contrário, defina-a e adicione as novas entradas:

if [ "$MYPATHS" != "true" ]; then
    export MYPATHS="true"
    export PATH="$PATH:$HOME/bin:"

    # java stuff
    export JAVA_HOME="$(/usr/libexec/java_home)"
    export M2_HOME="$HOME/Applications/apache-maven-3.3.9"
    export PATH="$JAVA_HOME/bin:$M2_HOME/bin:$PATH"

    # etc...
fi

Obviamente, essas entradas ainda poderão ser duplicadas se adicionadas por outro script, como /etc/profile.

Este script permite adicionar no final de $PATH:

PATH=path2; add_to_PATH after path1 path2:path3
echo $PATH
path2:path1:path3

Ou adicione no início de $PATH:

PATH=path2; add_to_PATH before path1 path2:path3
echo $PATH
path1:path3:path2

# Add directories to $PATH iff they're not already there
# Append directories to $PATH by default
# Based on https://unix.stackexchange.com/a/4973/143394
# and https://unix.stackexchange.com/a/217629/143394
add_to_PATH () {
  local prepend  # Prepend to path if set
  local prefix   # Temporary prepended path
  local IFS      # Avoid restoring for added laziness

  case $1 in
    after)  shift;; # Default is to append
    before) prepend=true; shift;;
  esac

  for arg; do
    IFS=: # Split argument by path separator
    for dir in $arg; do
      # Canonicalise symbolic links
      dir=$({ cd -- "$dir" && { pwd -P || pwd; } } 2>/dev/null)
      if [ -z "$dir" ]; then continue; fi  # Skip non-existent directory
      case ":$PATH:" in
        *":$dir:"*) :;; # skip - already present
        *) if [ "$prepend" ]; then
           # ${prefix:+$prefix:} will expand to "" if $prefix is empty to avoid
           # starting with a ":".  Expansion is "$prefix:" if non-empty.
            prefix=${prefix+$prefix:}$dir
          else
            PATH=$PATH:$dir  # Append by default
          fi;;
      esac
    done
  done
  [ "$prepend" ] && PATH=$prefix:$PATH
}

Aqui está uma maneira compatível com POSIX.

# USAGE: path_add [include|prepend|append] "dir1" "dir2" ...
#   prepend: add/move to beginning
#   append:  add/move to end
#   include: add to end of PATH if not already included [default]
#          that is, don't change position if already in PATH
# RETURNS:
# prepend:  dir2:dir1:OLD_PATH
# append:   OLD_PATH:dir1:dir2
# If called with no paramters, returns PATH with duplicate directories removed
path_add() {
    # use subshell to create "local" variables
    PATH="$(path_unique)"
    export PATH="$(path_add_do "$@")"
}

path_add_do() {
    case "$1" in
    'include'|'prepend'|'append') action="$1"; shift ;;
    *)                            action='include'   ;;
    esac

    path=":$PATH:" # pad to ensure full path is matched later

    for dir in "$@"; do
        #       [ -d "$dir" ] || continue # skip non-directory params

        left="${path%:$dir:*}" # remove last occurrence to end

        if [ "$path" = "$left" ]; then
            # PATH doesn't contain $dir
            [ "$action" = 'include' ] && action='append'
            right=''
        else
            right=":${path#$left:$dir:}" # remove start to last occurrence
        fi

        # construct path with $dir added
        case "$action" in
            'prepend') path=":$dir$left$right" ;;
            'append')  path="$left$right$dir:" ;;
        esac
    done

    # strip ':' pads
    path="${path#:}"
    path="${path%:}"

    # return
    printf '%s' "$path"
}

# USAGE: path_unique [path]
# path - a colon delimited list. Defaults to $PATH is not specified.
# RETURNS: `path` with duplicated directories removed
path_unique() {
    in_path=${1:-$PATH}
    path=':'

    # Wrap the while loop in '{}' to be able to access the updated `path variable
    # as the `while` loop is run in a subshell due to the piping to it.
    # https://stackoverflow.com/questions/4667509/shell-variables-set-inside-while-loop-not-visible-outside-of-it
    printf '%s\n' "$in_path" \
    | /bin/tr -s ':' '\n'    \
    | {
            while read -r dir; do
                left="${path%:$dir:*}" # remove last occurrence to end
                if [ "$path" = "$left" ]; then
                    # PATH doesn't contain $dir
                    path="$path$dir:"
                fi
            done
            # strip ':' pads
            path="${path#:}"
            path="${path%:}"
            # return
            printf '%s\n' "$path"
        }
}

É extraído da resposta de Guillaume Perrault-Archambault a esta pergunta e da resposta de mike511 aqui .

UPDATE 2017-11-23: Bug corrigido por @Scott