Thêm thư mục vào $ PATH nếu nó chưa có

Có ai đã viết một hàm bash để thêm một thư mục vào $ PATH chỉ khi nó chưa có ở đó?

Tôi thường thêm vào PATH bằng cách sử dụng một cái gì đó như:

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

Nếu tôi xây dựng PATH của mình trong .bash_profile, thì nó sẽ không được đọc trừ khi phiên tôi tham gia là phiên đăng nhập - điều này không phải lúc nào cũng đúng. Nếu tôi xây dựng PATH của mình trong .bashrc, thì nó sẽ chạy với mỗi lớp con. Vì vậy, nếu tôi khởi chạy một cửa sổ Terminal và sau đó chạy màn hình và sau đó chạy một kịch bản shell, tôi nhận được:

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

Tôi sẽ thử xây dựng một hàm bash được gọi là add_to_path()chỉ thêm thư mục nếu nó không có ở đó. Nhưng, nếu bất cứ ai đã viết (hoặc tìm thấy) một điều như vậy, tôi sẽ không dành thời gian cho nó.

Từ .bashrc của tôi:

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

Lưu ý rằng PATH phải được đánh dấu là đã xuất, do đó không cần nhập lại. Điều này kiểm tra xem thư mục có tồn tại & là một thư mục trước khi thêm nó, mà bạn có thể không quan tâm.

Ngoài ra, điều này thêm thư mục mới vào cuối đường dẫn; để đặt ở đầu, sử dụng PATH="$1${PATH:+":$PATH"}"thay vì PATH=dòng trên .

Mở rộng câu trả lời của Gordon Davisson, điều này hỗ trợ nhiều đối số

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

Vì vậy, bạn có thể thực hiện pathappend path1 path2 path3 ...

Để trả trước,

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

Tương tự như pathappend, bạn có thể làm

pathprepend path1 path2 path3 ...

Đây là một cái gì đó từ câu trả lời của tôi cho câu hỏi này kết hợp với cấu trúc chức năng của Doug Harris. Nó sử dụng các biểu thức chính quy Bash:

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

Đặt ý kiến ​​này trong các bình luận cho câu trả lời đã chọn, nhưng các bình luận dường như không hỗ trợ định dạng PRE, vì vậy hãy thêm câu trả lời vào đây:

@ gordon-davisson Tôi không phải là một fan hâm mộ lớn của việc trích dẫn & ghép nối không cần thiết. Giả sử bạn đang sử dụng phiên bản bash> = 3, thay vào đó, bạn có thể sử dụng regexs tích hợp sẵn của bash và thực hiện:

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

Điều này không xử lý chính xác các trường hợp có không gian trong thư mục hoặc PATH. Có một số câu hỏi là liệu công cụ regex tích hợp của bash có đủ chậm để điều này có thể kém hiệu quả hơn so với phép nối và nội suy chuỗi mà phiên bản của bạn thực hiện hay không, nhưng bằng cách nào đó, nó chỉ mang lại cảm giác thẩm mỹ hơn cho tôi.

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
}

Khi bạn cần $ HOME / thùng để xuất hiện chính xác một lần vào đầu $ PATH của bạn và không ở đâu khác, chấp nhận không có sản phẩm thay thế.

Đây là một giải pháp thay thế có lợi thế bổ sung là loại bỏ các mục thừa:

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

Đối số duy nhất cho hàm này được thêm vào PATH và trường hợp đầu tiên của cùng một chuỗi được xóa khỏi đường dẫn hiện có. Nói cách khác, nếu thư mục đã tồn tại trong đường dẫn, nó được thăng cấp lên phía trước chứ không được thêm dưới dạng trùng lặp.

Hàm này hoạt động bằng cách thêm dấu hai chấm vào đường dẫn để đảm bảo rằng tất cả các mục có dấu hai chấm ở phía trước, và sau đó chuẩn bị mục mới cho đường dẫn hiện có với mục đó đã bị xóa. Phần cuối cùng được thực hiện bằng cách sử dụng ${var//pattern/sub}ký hiệu của bash ; xem hướng dẫn sử dụng bash để biết thêm chi tiết.

Đây là của tôi (tôi tin rằng nó đã được viết bởi Oscar, sysadmin của phòng thí nghiệm cũ của tôi, tất cả đều là tín dụng của anh ấy), nó đã xuất hiện trong bashrc của tôi từ lâu. Nó có thêm lợi ích là cho phép bạn thêm trước hoặc nối thêm thư mục mới theo ý muốn:

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

Sử dụng:

$ 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/

Để trả trước, tôi thích giải pháp của @ Russell, nhưng có một lỗi nhỏ: nếu bạn cố gắng thêm một cái gì đó như "/ bin" vào đường dẫn "/ sbin: / usr / bin: / var / usr / bin: / usr / local / bin: / usr / sbin "nó thay thế" / bin: "3 lần (khi nó không thực sự khớp với nhau). Kết hợp một bản sửa lỗi cho giải pháp bổ sung từ @ gordon-davisson, tôi nhận được điều này:

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
}

Một bí danh đơn giản như thế này dưới đây nên thực hiện mẹo:

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

Tất cả những gì nó làm là phân chia đường dẫn trên: ký tự và so sánh từng thành phần với đối số bạn truyền vào. Grep kiểm tra xem có khớp dòng hoàn chỉnh không và in ra số đếm.

Sử dụng mẫu:

$ 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

Thay thế lệnh echo bằng addToPath hoặc một số bí danh / hàm tương tự.

Xem Làm thế nào để tránh trùng lặp biến đường dẫn trong csh? trên StackOverflow cho một bộ câu trả lời cho câu hỏi này.

Đây là những gì tôi đã đánh lên:

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
}

Bây giờ trong .bashrc tôi có:

add_to_path /usr/local/mysql/bin

Phiên bản cập nhật sau bình luận về cách bản gốc của tôi sẽ không xử lý các thư mục có khoảng trắng (nhờ câu hỏi này để chỉ cho tôi sử dụng 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
}

Tôi hơi ngạc nhiên khi chưa có ai đề cập đến vấn đề này, nhưng bạn có thể sử dụng readlink -fđể chuyển đổi các đường dẫn tương đối thành các đường dẫn tuyệt đối và thêm chúng vào PATH như vậy.

Ví dụ: để cải thiện câu trả lời của Guillaume Perrault-Archambault,

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

trở thành

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. Những điều cơ bản - Điều này có ích gì?

Các readlink -flệnh sẽ (trong số những thứ khác) chuyển đổi một đường dẫn tương đối đến một đường dẫn tuyệt đối. Điều này cho phép bạn làm một cái gì đó như

$ cd / đường dẫn / đến / của tôi / bin / dir
$ pathappend .
$ echo "$ PATH"
<your_old_path> : / path / to / my / bin / dir

2. Tại sao chúng ta thử nghiệm để được ở trong hai lần?

Vâng, hãy xem xét ví dụ trên. Nếu người dùng nói từ thư mục lần thứ hai, sẽ có . Tất nhiên, sẽ không có mặt trong . Nhưng sau đó sẽ được thiết lập để (đường dẫn tuyệt đối tương đương ), mà là đã có trong . Vì vậy, chúng ta cần tránh thêm vào lần thứ hai.pathappend ./path/to/my/bin/dirARG..PATHARGA/path/to/my/bin/dir.PATH/path/to/my/bin/dirPATH

Có lẽ quan trọng hơn, mục đích chính của readlink, như tên của nó ngụ ý, để xem xét một liên kết tượng trưng và đọc tên đường dẫn mà nó chứa (nghĩa là trỏ đến). Ví dụ:

$ 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

Bây giờ, nếu bạn nói pathappend /usr/lib/perl/5.14, và bạn đã có /usr/lib/perl/5.14trong ĐƯỜNG của bạn, tốt, điều đó tốt; chúng ta có thể để nó như vậy Nhưng, nếu /usr/lib/perl/5.14chưa có trong PATH của bạn, chúng tôi gọi readlinkvà get ARGA= /usr/lib/perl/5.14.2, và sau đó chúng tôi thêm nó vào PATH. Nhưng hãy đợi một phút - nếu bạn đã nói pathappend /usr/lib/perl/5.14, thì bạn đã có /usr/lib/perl/5.14.2trong ĐƯỜNG của bạn, và, một lần nữa, chúng ta cần kiểm tra điều đó để tránh thêm nó vào PATHlần thứ hai.

3. Thỏa thuận với if ARGA=$(readlink -f "$ARG")cái gì?

Trong trường hợp không rõ ràng, dòng này kiểm tra xem liệu readlinkthành công. Đây chỉ là tốt, thực hành lập trình phòng thủ. Nếu chúng ta sẽ sử dụng đầu ra từ lệnh  m như một phần của lệnh  n (trong đó m  <  n ), thì nên kiểm tra xem lệnh  m có bị lỗi hay không và xử lý theo cách nào đó. Tôi không nghĩ rằng nó có khả năng readlinksẽ thất bại - nhưng, như đã thảo luận trong Cách lấy đường dẫn tuyệt đối của một tệp tùy ý từ OS X và các nơi khác, readlinklà một phát minh GNU. Nó không được chỉ định trong POSIX, vì vậy tính khả dụng của nó trong Mac OS, Solaris và các Unix không phải Linux khác là đáng nghi ngờ. (Trên thực tế, tôi vừa đọc một bình luận nói rằngreadlink -fdường như không hoạt động trên Mac OS X 10.11.6, nhưng realpathhoạt động vượt trội . Vì vậy, nếu bạn đang sử dụng hệ thống không có readlinkhoặc readlink -fkhông hoạt động, bạn có thể sửa đổi điều này script để sử dụng realpath.) Bằng cách cài đặt một mạng lưới an toàn, chúng tôi làm cho mã của chúng tôi dễ mang theo hơn.

Tất nhiên, nếu bạn trên một hệ thống không có readlink(hoặc  realpath), bạn sẽ không muốn làm .pathappend .

Bài -dkiểm tra thứ hai ( [ -d "$ARGA" ]) thực sự có lẽ không cần thiết. Tôi không thể nghĩ ra bất kỳ kịch bản nào $ARGlà thư mục và readlinkthành công, nhưng  $ARGAkhông phải là thư mục. Tôi chỉ sao chép và dán ifcâu lệnh đầu tiên để tạo câu lệnh thứ ba, và tôi rời khỏi  -dbài kiểm tra ở đó vì sự lười biếng.

4. Có ý kiến ​​nào khác không?

Vâng. Giống như nhiều câu trả lời khác ở đây, câu trả lời này kiểm tra xem mỗi đối số có phải là một thư mục hay không, xử lý nó nếu có và bỏ qua nó nếu không. Điều này có thể (hoặc có thể không) là đầy đủ nếu bạn pathappend chỉ sử dụng trong .các tập tin của EDR (như .bash_profilevà .bashrc) và các tập lệnh khác. Nhưng, như câu trả lời này cho thấy (ở trên), việc sử dụng nó một cách tương tác là hoàn toàn khả thi. Bạn sẽ rất bối rối nếu bạn làm

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

Bạn có nhận thấy rằng tôi đã nói nysql trong pathappendlệnh, hơn là mysql? Và điều đó pathappendkhông nói lên điều gì; Nó chỉ âm thầm bỏ qua lập luận không chính xác?

Như tôi đã nói ở trên, đó là cách thực hành tốt để xử lý lỗi. Đây là một ví dụ:

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  
}  

Cách này hoạt động tốt:

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

Các phiên bản của tôi ít cẩn thận hơn về các đường dẫn trống và khăng khăng các đường dẫn là hợp lệ và các thư mục so với một số được đăng ở đây, nhưng tôi tìm thấy một bộ sưu tập lớn về trả trước / chắp thêm / sạch / unique-ify / etc. các hàm shell sẽ hữu ích cho thao tác đường dẫn. Toàn bộ, ở trạng thái hiện tại của họ, có ở đây: http://pastebin.com/xS9sgQsX (phản hồi và cải tiến rất đáng hoan nghênh!)

Bạn có thể sử dụng một lớp lót perl:

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;' "$@"
}

Đây là trong 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
}

Tôi đã sửa đổi một chút câu trả lời của Gordon Davisson để sử dụng thư mục hiện tại nếu không được cung cấp. Vì vậy, bạn chỉ có thể làm paddtừ thư mục bạn muốn thêm vào PATH của bạn.

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

Bạn có thể kiểm tra xem một biến tùy chỉnh đã được đặt chưa, nếu không thì đặt nó và sau đó thêm các mục mới:

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

Tất nhiên, các mục này vẫn có thể được sao chép nếu được thêm bởi một tập lệnh khác, chẳng hạn như /etc/profile.

Kịch bản này cho phép bạn thêm vào cuối $PATH:

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

Hoặc thêm vào đầu $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
}

Đây là một cách tuân thủ 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"
        }
}

Nó được viết từ câu trả lời của Guillaume Perrault-Archambault cho câu hỏi này và câu trả lời của mike511 ở đây .

CẬP NHẬT 2017-11-23: Đã sửa lỗi mỗi @Scott