เพิ่มไดเรกทอรีไปยัง $ PATH หากยังไม่มี

มีใครเขียนฟังก์ชั่นทุบตีเพื่อเพิ่มไดเรกทอรีไปยัง $ PATH เท่านั้นหากยังไม่ได้มี?

ฉันมักจะเพิ่มเส้นทางโดยใช้สิ่งที่ชอบ:

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

หากฉันสร้าง PATH ของฉันใน. bash_profile แสดงว่าไม่ได้อ่านยกเว้นว่าเซสชันที่ฉันใช้อยู่นั้นเป็นเซสชันการเข้าสู่ระบบซึ่งไม่ได้เป็นจริงเสมอไป ถ้าฉันสร้าง PATH ของฉันใน. bashrc มันจะทำงานกับแต่ละ subshell ดังนั้นถ้าฉันเปิดหน้าต่างเทอร์มินัลแล้วเรียกใช้หน้าจอแล้วเรียกใช้สคริปต์เชลล์ฉันจะได้รับ:

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

ฉันจะลองสร้างฟังก์ชั่นทุบตีที่เรียกว่าadd_to_path()เพิ่มเฉพาะไดเรกทอรีถ้ามันไม่ได้มี แต่ถ้าใครได้เขียน (หรือพบ) สิ่งนั้นฉันจะไม่ใช้เวลากับมัน

จาก. bashrc ของฉัน:

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

โปรดทราบว่า PATH ควรได้รับการทำเครื่องหมายว่าส่งออกแล้วดังนั้นจึงไม่จำเป็นต้องส่งออกอีกครั้ง การตรวจสอบนี้จะตรวจสอบว่าไดเรกทอรีนั้นมีอยู่ & เป็นไดเรกทอรีก่อนที่จะเพิ่มซึ่งคุณอาจไม่สนใจ

นอกจากนี้จะเพิ่มไดเรกทอรีใหม่ไปยังจุดสิ้นสุดของเส้นทาง เพื่อวางที่จุดเริ่มต้นใช้PATH="$1${PATH:+":$PATH"}"แทนPATH=บรรทัดข้างต้น

การขยายตามคำตอบของ Gordon Davisson สิ่งนี้สนับสนุนอาร์กิวเมนต์หลายตัว

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

ดังนั้นคุณสามารถทำ pathappend path1 path2 path3 ...

สำหรับการเตรียม

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

คุณสามารถทำได้เช่นเดียวกับ pathappend

pathprepend path1 path2 path3 ...

นี่คือบางอย่างจากคำตอบของฉันไปที่คำถามนี้รวมกับโครงสร้างของฟังก์ชั่นดั๊กแฮร์ริส มันใช้นิพจน์ปกติของ Bash:

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

ใส่สิ่งนี้ในความคิดเห็นของคำตอบที่เลือก แต่ความคิดเห็นดูเหมือนจะไม่สนับสนุนการจัดรูปแบบ PRE ดังนั้นให้เพิ่มคำตอบที่นี่:

@ gordon-davisson ฉันไม่ได้เป็นแฟนตัวยงของการพูดไม่จำเป็น & การต่อกัน สมมติว่าคุณใช้ bash version> = 3 คุณสามารถใช้ regex ของ built-in และทำสิ่งต่อไปนี้

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

สิ่งนี้จัดการกรณีที่มีช่องว่างในไดเรกทอรีหรือ PATH อย่างถูกต้อง มีคำถามบางอย่างเกี่ยวกับว่า bash ที่สร้างขึ้นในเอ็นจิน regex นั้นช้าพอหรือไม่ซึ่งอาจจะมีประสิทธิภาพน้อยกว่าการต่อสตริงและการแก้ไขที่เวอร์ชั่นของคุณทำ

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
}

เมื่อคุณต้องการ $ HOME / bin ปรากฏอย่างแน่นอนหนึ่งครั้งที่จุดเริ่มต้นของ $ PATH และไม่มีที่อื่นให้ยอมรับไม่ทดแทน

นี่คือโซลูชันทางเลือกที่มีข้อได้เปรียบเพิ่มเติมในการลบรายการที่ซ้ำซ้อน:

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

อาร์กิวเมนต์เดียวของฟังก์ชั่นนี้ได้รับการต่อท้ายไปที่ PATH และอินสแตนซ์แรกของสตริงเดียวกันจะถูกลบออกจากเส้นทางที่มีอยู่ กล่าวอีกนัยหนึ่งถ้าไดเรกทอรีมีอยู่แล้วในเส้นทางมันจะเลื่อนไปข้างหน้ามากกว่าที่จะเพิ่มเป็นที่ซ้ำกัน

ฟังก์ชั่นการทำงานโดยการเพิ่มลำไส้ใหญ่ไปยังเส้นทางเพื่อให้แน่ใจว่ารายการทั้งหมดมีลำไส้ใหญ่ที่ด้านหน้าและจากนั้นการเตรียมรายการใหม่ไปยังเส้นทางที่มีอยู่กับรายการที่ถูกลบออก ส่วนสุดท้ายจะดำเนินการโดยใช้${var//pattern/sub}สัญกรณ์ของทุบตี; ดูคู่มือทุบตีสำหรับรายละเอียดเพิ่มเติม

นี่คือของฉัน (ฉันเชื่อว่ามันถูกเขียนเมื่อหลายปีก่อนโดยออสการ์ผู้ดูแลระบบของแล็บเก่าของฉันเครดิตทั้งหมดให้เขา) มันอยู่ในแบชช์ของฉันมานาน มันมีประโยชน์เพิ่มเติมในการช่วยให้คุณสามารถเพิ่มหรือผนวกไดเรกทอรีใหม่ตามที่ต้องการ:

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

การใช้งาน:

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

สำหรับการต่อเติมฉันชอบวิธีแก้ปัญหาของ @ Russell แต่มีข้อผิดพลาดเล็กน้อย: หากคุณพยายามเติมบางสิ่งเช่น "/ bin" ไปยังเส้นทางของ "/ sbin: / usr / bin: / var / usr / bin: / usr / local / bin: / usr / sbin "มันจะแทนที่" / bin: "3 ครั้ง (เมื่อไม่ตรงกันเลย) เมื่อรวมการแก้ไขเข้ากับโซลูชันผนวกท้ายจาก @ gordon-davisson ฉันได้สิ่งนี้:

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
}

นามแฝงง่ายๆแบบนี้ด้านล่างควรทำเคล็ดลับ:

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

สิ่งที่มันทำคือแบ่งพา ธ บนอักขระ: และเปรียบเทียบแต่ละคอมโพเนนต์กับอาร์กิวเมนต์ที่คุณส่งผ่าน grep ตรวจสอบการจับคู่บรรทัดทั้งหมดแล้วพิมพ์จำนวนนับ

ตัวอย่างการใช้งาน:

$ 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

แทนที่คำสั่ง echo ด้วย addToPath หรือนามแฝง / ฟังก์ชันที่คล้ายกัน

ดูวิธีการหลีกเลี่ยงการทำซ้ำตัวแปรพา ธ ใน csh บน StackOverflow สำหรับคำตอบหนึ่งชุดสำหรับคำถามนี้

นี่คือสิ่งที่ฉันทำขึ้น:

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
}

ตอนนี้ใน. bashrc ฉันมี:

add_to_path /usr/local/mysql/bin

อัปเดตเวอร์ชันต่อไปนี้แสดงความคิดเห็นเกี่ยวกับวิธีที่ต้นฉบับของฉันจะไม่จัดการกับไดเรกทอรีที่มีช่องว่าง (ขอบคุณสำหรับคำถามนี้ชี้ให้ฉันใช้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
}

ฉันรู้สึกประหลาดใจเล็กน้อยที่ไม่มีใครพูดถึงเรื่องนี้ แต่คุณสามารถใช้readlink -fในการแปลงเส้นทางสัมพัทธ์เป็นเส้นทางที่แน่นอนและเพิ่มลงในเส้นทางดังกล่าว

ตัวอย่างเช่นเพื่อปรับปรุงคำตอบของ Guillaume Perrault-Archambault

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

กลายเป็น

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. พื้นฐาน - มันทำอะไรได้ดี?

readlink -fคำสั่งจะ (เหนือสิ่งอื่น) แปลงเส้นทางเทียบกับเส้นทางที่แน่นอน สิ่งนี้ช่วยให้คุณทำสิ่งที่ชอบ

$ cd / path / to / my / bin / dir
$ pathappend
$ echo "$ PATH"
<your_old_path> : / path / to / my / bin / dir

2. ทำไมเราทดสอบว่าอยู่ในเส้นทางที่สองหรือไม่

ลองพิจารณาตัวอย่างข้างต้น หากผู้ใช้กล่าวว่า จากไดเรกทอรีเป็นครั้งที่สอง จะเป็น แน่นอนว่าจะไม่อยู่ใน แต่แล้วจะถูกตั้งค่า (เทียบเท่าเส้นทางที่แน่นอนของ) ซึ่งเป็นแล้วใน ดังนั้นเราจึงจำเป็นที่จะต้องหลีกเลี่ยงการเพิ่มที่จะเป็นครั้งที่สองpathappend ./path/to/my/bin/dirARG..PATHARGA/path/to/my/bin/dir.PATH/path/to/my/bin/dirPATH

บางทีสิ่งที่สำคัญกว่านั้นจุดประสงค์หลักของreadlinkชื่อก็คือการมองไปที่ลิงก์สัญลักษณ์และอ่านชื่อพา ธ ที่มี (กล่าวคือชี้ไปที่) ตัวอย่างเช่น:

$ 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

ตอนนี้ถ้าคุณพูดpathappend /usr/lib/perl/5.14และคุณมี/usr/lib/perl/5.14อยู่ในเส้นทางของคุณแล้วก็ไม่เป็นไร เราสามารถทิ้งมันไว้อย่างที่มันเป็น แต่ถ้า/usr/lib/perl/5.14ไม่ได้อยู่ในเส้นทางของคุณเราเรียกreadlinkและได้รับARGA= /usr/lib/perl/5.14.2แล้วเราเพิ่มที่PATHจะ แต่รอสักครู่ - ถ้าคุณอยู่แล้วกล่าวว่าpathappend /usr/lib/perl/5.14แล้วคุณมีอยู่แล้ว/usr/lib/perl/5.14.2ในเส้นทางของคุณและอีกครั้งเราจำเป็นต้องตรวจสอบเพื่อที่จะหลีกเลี่ยงการเพิ่มมันจะPATHเป็นครั้งที่สอง

3. อะไรคือข้อตกลงกับif ARGA=$(readlink -f "$ARG")?

ในกรณีที่ไม่ชัดเจนบรรทัดนี้จะทดสอบว่าreadlinkสำเร็จหรือไม่ นี่เป็นเพียงวิธีการเขียนโปรแกรมที่ดีและป้องกัน หากเรากำลังจะใช้เอาท์พุทจากคำสั่ง  m เป็นส่วนหนึ่งของคำสั่ง  n (โดยที่m  <  n ) ก็ควรระมัดระวังที่จะตรวจสอบว่าคำสั่ง  mล้มเหลวและจัดการมันในบางวิธี ฉันไม่คิดว่าเป็นไปได้ที่readlinkจะล้มเหลว - แต่ตามที่กล่าวไว้ในวิธีการเรียกเส้นทางสัมบูรณ์ของไฟล์โดยพลการจาก OS X และที่อื่น ๆreadlinkเป็นสิ่งประดิษฐ์ของ GNU มันไม่ได้ระบุใน POSIX ดังนั้นความพร้อมใช้งานใน Mac OS, Solaris และ Unixes อื่น ๆ ที่ไม่ใช่ Linux น่าสงสัย (อันที่จริงฉันเพิ่งอ่านความคิดเห็นที่ระบุว่า“readlink -fดูเหมือนจะไม่ทำงานบน Mac OS X 10.11.6 แต่realpathทำงานนอกกรอบได้” ดังนั้นหากคุณอยู่ในระบบที่ไม่มีreadlinkหรือที่readlink -fใช้งานไม่ได้คุณอาจแก้ไขได้ สคริปต์ที่จะใช้realpath) โดยการติดตั้งเครือข่ายความปลอดภัยเราทำให้โค้ดของเราค่อนข้างพกพามากขึ้น

แน่นอนถ้าคุณอยู่ในระบบที่ไม่ได้readlink(หรือ  realpath), คุณจะไม่ต้องการที่จะทำpathappend .

การ-dทดสอบครั้งที่สอง( [ -d "$ARGA" ]) อาจไม่จำเป็นจริงๆ ฉันไม่สามารถนึกถึงสถานการณ์ใด ๆ ที่$ARGเป็นไดเรกทอรีและreadlinkประสบความสำเร็จ แต่  $ARGAไม่ใช่ไดเรกทอรี ฉันเพิ่งคัดลอกและวางifคำสั่งแรกเพื่อสร้างคำสั่งที่สามและฉันออกจากการ  -dทดสอบที่นั่นด้วยความเกียจคร้าน

4. ความคิดเห็นอื่น ๆ ?

ใช่. เช่นเดียวกับคำตอบอื่น ๆ มากมายที่นี่อันนี้ทดสอบว่าแต่ละอาร์กิวเมนต์เป็นไดเรกทอรีประมวลผลถ้ามันเป็นและไม่สนใจถ้ามันไม่ได้ สิ่งนี้อาจ (หรืออาจไม่) เพียงพอหากคุณใช้pathappend เฉพาะใน.ไฟล์“” (เช่น.bash_profileและ.bashrc) และสคริปต์อื่น ๆ แต่ดังที่คำตอบนี้แสดงให้เห็น (ด้านบน) มันเป็นไปได้อย่างสมบูรณ์แบบที่จะใช้มันแบบโต้ตอบ คุณจะงงมากถ้าคุณทำ

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

คุณสังเกตเห็นว่าฉันพูดnysql ในpathappendคำสั่งมากกว่าmysql? และนั่นpathappendไม่ได้พูดอะไรเลย เป็นเพียงการเพิกเฉยต่ออาร์กิวเมนต์ที่ไม่ถูกต้องหรือไม่

ดังที่ฉันได้กล่าวไว้ข้างต้นเป็นวิธีปฏิบัติที่ดีในการจัดการข้อผิดพลาด นี่คือตัวอย่าง:

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  
}  

วิธีนี้ใช้งานได้ดี:

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

เวอร์ชันของฉันไม่ค่อยระมัดระวังเกี่ยวกับพา ธ ที่ว่างเปล่าและยืนยันในพา ธ ที่ถูกต้องและไดเรกทอรีกว่าบางโพสต์ที่นี่ แต่ฉันพบคอลเลกชันที่มีขนาดใหญ่ของการผนวก / ผนวก / clean / unique-ify / etc ฟังก์ชั่นเปลือกเพื่อเป็นประโยชน์สำหรับการจัดการเส้นทาง ล็อตทั้งหมดในสถานะปัจจุบันของพวกเขาอยู่ที่นี่: http://pastebin.com/xS9sgQsX (ข้อเสนอแนะและการปรับปรุงยินดีอย่างมาก!)

คุณสามารถใช้ 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;' "$@"
}

ที่นี่มันอยู่ในทุบตี:

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
}

ฉันแก้ไขคำตอบของ Gordon Davissonเล็กน้อยเพื่อใช้ dir ปัจจุบันหากไม่มีให้ ดังนั้นคุณสามารถทำได้paddจากไดเรกทอรีที่คุณต้องการจะเพิ่มใน PATH ของคุณ

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

คุณสามารถตรวจสอบว่ามีการตั้งค่าตัวแปรที่กำหนดเองมิฉะนั้นให้ตั้งค่าแล้วเพิ่มรายการใหม่:

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

/etc/profileแน่นอนว่ารายการเหล่านี้จะยังคงได้ซ้ำหากมีการเพิ่มโดยสคริปต์อื่นเช่น

สคริปต์นี้ให้คุณเพิ่มในตอนท้ายของ$PATH:

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

หรือเพิ่มที่จุดเริ่มต้นของ$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
}

นี่คือวิธีที่เป็นไปตาม 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"
        }
}

มันเป็น cribbed จากกีโยมแปร์โรลท์-Archambault 'คำตอบของคำถามนี้และmike511 ' s คำตอบที่นี่

UPDATE 2017-11-23: แก้ไขข้อผิดพลาดต่อ @Scott