it-swarm-tr.com

PATH'ye doğru bir yol nasıl eklenir?

Nerede PATH ortam değişkenine yeni bir yol eklenmesi gerektiğini merak ediyorum. Bunun .bashrc (örneğin), ancak bunun nasıl yapılacağı açık değildir.

Bu yoldan:

export PATH=~/opt/bin:$PATH

veya bu?

export PATH=$PATH:~/opt/bin
994
Paolo

Basit şeyler

PATH=$PATH:~/opt/bin

veya

PATH=~/opt/bin:$PATH

sonuna ~/opt/bin eklemek isteyip istemediğinize bağlı olarak (diğer tüm dizinlerden sonra aranacak, birden fazla dizinde aynı ada sahip bir program olması durumunda) veya başında (diğerlerinden önce aranacak) dizinleri).

Aynı anda birden çok giriş ekleyebilirsiniz. PATH=$PATH:~/opt/bin:~/opt/node/bin Veya siparişteki değişiklikler gayet iyi. Ek komplikasyonları olduğu için export satırının başına koymayın (aşağıda “Bash dışındaki mermiler hakkında notlar” bölümüne bakın).

PATH cihazınız birçok farklı bileşen tarafından oluşturulursa, yinelenen girişlerle karşılaşabilirsiniz. Bkz. Unix tarafından keşfedilecek giriş dizini yolu nasıl eklenir? ve Yinelenenleri eklemekten kaçınmak veya kaldırmak için yinelenen $ PATH girişlerini kaldırın .

Bazı dağıtımlar bu arada otomatik olarak PATH'nize ~/bin Yerleştirir.

Nereye koymalı

~/.profile Veya ~/.bash_profile İçindeki PATH değerini değiştirmek için satırı ekleyin.

~/.bash_rc Öğesinin hiçbir program tarafından okunmadığını ve ~/.bashrc Öğesinin etkileşimli bash örneklerinin yapılandırma dosyası olduğunu unutmayın. Ortam değişkenlerini ~/.bashrc İçinde tanımlamamalısınız. PATH gibi ortam değişkenlerini tanımlamak için doğru yer ~/.profile (Veya bash dışındaki mermileri umursamıyorsanız ~/.bash_profile). Bkz. Aralarındaki fark nedir ve hangisini kullanmalıyım?

/etc/environment Veya ~/.pam_environment İçine koymayın: bunlar Shell dosyaları değil, $PATH Gibi ikameleri kullanamazsınız. Bu dosyalarda, yalnızca bir değişkeni geçersiz kılabilir, ona eklenemez.

Bazı sistem betiklerinde olası komplikasyonlar

Değişken zaten ortamdaysa export'ye ihtiyacınız yoktur: değişkenin değerindeki herhangi bir değişiklik ortama yansır. ¹ PATH hemen hemen her zaman çevrede olur; tüm unix sistemleri bunu çok erken uygulamaya koydu (genellikle ilk işlemde).

Oturum açma sırasında, PATH'nin zaten ortamdayken ve bazı sistem dizinlerini içerdiğine güvenebilirsiniz. Bir tür sanal ortam kurarken erken çalıştırılabilecek bir komut dosyası yazıyorsanız, PATH öğesinin boş olmadığından ve dışa aktarıldığından emin olmanız gerekebilir: PATH hala ayarlanmamışsa , PATH=$PATH:/some/directory gibi bir şey PATH değerini :/some/directory olarak ayarlar ve başlangıçtaki boş bileşen geçerli dizin anlamına gelir (.:/some/directory gibi).

if [ -z "${PATH-}" ]; then export PATH=/usr/local/bin:/usr/bin:/bin; fi

Bash dışındaki mermilerle ilgili notlar

Bash, ksh ve zsh'de export özel bir sözdizimidir ve hem PATH=~/opt/bin:$PATH Hem de export PATH=~/opt/bin:$PATH Bile doğru olanı yapar. Tire (birçok sistemde /bin/sh) Gibi diğer Bourne/POSIX tarzı mermilerde, export, iki fark anlamına gelen sıradan bir komut olarak ayrıştırılır:

Yani çizgi gibi kabuklarda, export PATH=~/opt/bin:$PATH PATH değerini ~/opt/bin/: değişmez dizesine ve ardından ilk boşluğa kadar PATH değerine ayarlar. PATH=~/opt/bin:$PATH (Çıplak bir atama) alıntı gerektirmez ve doğru olanı yapar. Taşınabilir bir komut dosyasında export kullanmak istiyorsanız, Bourne Shell'e taşınabilirlik için export PATH="$HOME/opt/bin:$PATH" Veya PATH=~/opt/bin:$PATH; export PATH (Veya PATH=$HOME/opt/bin:$PATH; export PATH Yazmanız gerekir. export var=value kabul etmedi ve tilde genişletme yapmadı).

¹ Bu Bourne mermilerinde doğru değildi (gerçek Bourne Kabuğunda olduğu gibi, modern POSIX tarzı mermilerde değil), ama bu günlerde böyle eski mermilerle karşılaşmanız pek olası değil.

Her iki şekilde de çalışır, ancak aynı şeyi yapmazlar: PATH öğelerinin öğeleri soldan sağa işaretlenir. İlk örneğinizde, ~/opt/bin, örneğin /usr/bin, bu da istediğiniz gibi olabilir veya olmayabilir.

Özellikle, güvenlik açısından, ön tarafa yollar eklemek tehlikelidir, çünkü eğer birisi sizin ~/opt/bin, örneğin farklı bir ls koyabilirler; bu durumda muhtemelen /bin/ls fark etmeden. Şimdi ssh veya tarayıcınız ya da seçiminiz için de aynısını düşünün ...

88
Ulrich Schwarz

Soru 2 ile kafam karıştı (ilgisiz bir sorun nedeniyle sorudan kaldırıldığından beri):

Farklı satırlara daha fazla yol eklemenin uygulanabilir bir yolu nedir? Başlangıçta bunun hile yapabileceğini düşündüm:

export PATH=$PATH:~/opt/bin
export PATH=$PATH:~/opt/node/bin

ancak ikinci atama sadece ~/opt/node/bin, aynı zamanda önceden atanmış olan PATH.

Bu olası bir çözümdür:

export PATH=$PATH:~/opt/bin:~/opt/node/bin

ancak okunabilirlik için bir yol için bir atama yapmayı tercih ederim.

Eğer öyle diyorsan

PATH=~/opt/bin

pATH'nizde olacak tümü. PATH sadece bir ortam değişkenidir ve PATH'e eklemek istiyorsanız, değişkeni tam olarak istediğiniz içerikle yeniden oluşturmanız gerekir. Yani, soru 2'ye örnek olarak verdiğiniz şey, tam olarak sormak istediğiniz noktayı kaçırmadıkça yapmak istediğiniz şeydir.

Kodumda her iki formu da kullanıyorum. Potansiyel olarak eksik olan dizinleri barındırmak için üzerinde çalıştığım her makineye yüklediğim genel bir profilim var:

export PATH=/opt/bin:/usr/local/bin:/usr/contrib/bin:/bin:/usr/bin:/usr/sbin:/usr/bin/X11
# add optional items to the path
for bindir in $HOME/local/bin $HOME/bin; do
    if [ -d $bindir ]; then
        PATH=$PATH:${bindir}
    fi
done
39
Carl Cravens

Linux çalıştırılabilir arama yolunu $PATH Ortam değişkeni ile belirler. $PATH Ortam değişkeninin başına dizin/veri/myscripts eklemek için aşağıdakileri kullanın:

PATH=/data/myscripts:$PATH

Bu dizini yolun sonuna eklemek için aşağıdaki komutu kullanın:

PATH=$PATH:/data/myscripts

Ancak, bir komut dosyasının içinde bir ortam değişkeni ayarladığınızda, bu değişiklik yalnızca komut dosyasının içinde etkili olduğu için, bunlar yeterli değildir. Bu sınırlamanın sadece iki yolu vardır:

  • Komut dosyasının içinde, ortam değişkenini, komut dosyası tarafından çağrılan herhangi bir programda dışa aktarırsanız. Komut dosyasını çağıran programda etkili olmadığını unutmayın.
  • Komut dosyasını çağıran program bunu çağırmak yerine dahil ederek yaparsa, komut dosyasındaki ortam değişiklikleri çağrı programı içinde etkili olur. Bu dahil etme dot komutu veya source komutu ile yapılabilir.

Örnekler:

$HOME/myscript.sh
source $HOME/myscript.sh

Ekleme temel olarak "çağrılan" komut dosyasına "çağrılan" komut dosyasını dahil eder. C'deki #include'a benzer. Bu yüzden “arama” betiğinin veya programının içinde etkilidir. Ancak, elbette, çağıran program tarafından çağrılan herhangi bir program veya komut dosyasında etkili değildir. Çağrı zincirinin sonuna kadar etkili olabilmesi için, bir export komutuyla ortam değişkeninin ayarını izlemelisiniz.

Örnek olarak, bash Shell programı .bash_profile dosyasının içeriğini dahil ederek içerir. Aşağıdaki 2 satırı .bash_profile dosyasına yerleştirin:

PATH=$PATH:/data/myscripts
export PATH

etkili bir şekilde bu 2 satır kod bash programına koyar. Dolayısıyla bash içinde, $ PATH değişkeni $HOME/myscript.sh İçerir ve verme deyimi nedeniyle bash tarafından çağrılan tüm programlar değiştirilmiş $PATH Değişkenine sahiptir. Ve bir bash isteminden çalıştırdığınız herhangi bir program bash tarafından çağrıldığı için, bash isteminden çalıştırdığınız herhangi bir şey için yeni yol yürürlüktedir.

Alt satırda, yola yeni bir dizin eklemek için, dizini Kabuk'ta yer alan bir komut dosyasında $ PATH ortam değişkenine eklemeniz veya başına eklemeniz ve $PATH Ortam değişkenini dışa aktarmanız gerekir.

Daha fazla bilgi burada

25
Steve Brown

Bir süredir benimle, yinelemeler konusunda endişelenmenize gerek kalmadan yola eleman eklemeye yardımcı olan iki fonksiyon pathadd ve pathrm tuttum.

pathadd, tek bir yol bağımsız değişkeni ve isteğe bağlı bir after bağımsız değişkeni alır; bu seçenek, sağlandıysa PATH öğesine eklenecektir, aksi takdirde bunu ekler.

Neredeyse her durumda yola ekliyorsanız, zaten yoldaki herhangi bir şeyi geçersiz kılmak istersiniz, bu yüzden varsayılan olarak başa eklemeyi tercih ederim.

pathadd() {
    newelement=${1%/}
    if [ -d "$1" ] && ! echo $PATH | grep -E -q "(^|:)$newelement($|:)" ; then
        if [ "$2" = "after" ] ; then
            PATH="$PATH:$newelement"
        else
            PATH="$newelement:$PATH"
        fi
    fi
}

pathrm() {
    PATH="$(echo $PATH | sed -e "s;\(^\|:\)${1%/}\(:\|\$\);\1\2;g" -e 's;^:\|:$;;g' -e 's;::;:;g')"
}

Bunları PATH ortamını değiştirmek istediğiniz herhangi bir komut dosyasına koyun ve şimdi yapabilirsiniz.

pathadd "/foo/bar"
pathadd "/baz/bat" after
export PATH

Zaten oradaysa, yola eklememeniz garanti edilir. Şimdi /baz/bat başlangıçta.

pathrm "/baz/bat"
pathadd "/baz/bat"
export PATH

Şimdi iki katına çıkmadan zaten yoldaysa, herhangi bir yol öne doğru hareket ettirilebilir.

20
Brett Ryan

Diğer dağıtımlar için konuşamam, ancak Ubuntu'nun tüm dosyaları için varsayılan arama yolu olan bir/etc/ortamı var. Bilgisayarım sadece benim tarafımdan kullanıldığından, bir komut dosyasına koyduğum geçici bir ek değilse, yolumda istediğim dizinleri oraya koydum.

10
Jim Bradley

PATH=/a/b:$PATH, PATH yolunu eklemenin "yanlış" yolu olarak düşünülebilir:

  1. Aslında dizin olmayan bir yol ekleme.
  2. Aynı formda zaten PATH olan bir yol ekleme.
  3. Göreli bir yol ekleme (geçerli çalışma dizinini değiştirdikçe, aranan gerçek dizin değişeceğinden).
  4. Zaten PATH içinde bulunan bir yolu farklı bir biçimde (yani, sembolik bağlantıları veya ..).
  5. 4 yapmaktan kaçınırsanız, PATH içindeki diğer girişleri geçersiz kılmak istendiğinde yolu PATH öğesinin önüne taşımamak.

Bu (yalnızca Bash) işlevi, yukarıdaki durumlarda (istisna dışında, aşağıya bakın) "doğru olanı" yapar, hata kodlarını döndürür ve insanlar için güzel mesajlar yazdırır. Hata kodları ve mesajlar istenmediklerinde devre dışı bırakılabilir.

prepath() {
    local usage="\
Usage: prepath [-f] [-n] [-q] DIR
  -f Force dir to front of path even if already in path
  -n Nonexistent dirs do not return error status
  -q Quiet mode"

    local tofront=false errcode=1 qecho=echo
    while true; do case "$1" in
        -f)     tofront=true;       shift;;
        -n)     errcode=0;          shift;;
        -q)     qecho=':';          shift;;
        *)      break;;
    esac; done
    # Bad params always produce message and error code
    [[ -z $1 ]] && { echo 1>&2 "$usage"; return 1; }

    [[ -d $1 ]] || { $qecho 1>&2 "$1 is not a directory."; return $errcode; }
    dir="$(command cd "$1"; pwd -P)"
    if [[ :$PATH: =~ :$dir: ]]; then
        $tofront || { $qecho 1>&2 "$dir already in path."; return 0; }
        PATH="${PATH#$dir:}"        # remove if at start
        PATH="${PATH%:$dir}"        # remove if at end
        PATH="${PATH//:$dir:/:}"    # remove if in middle
    fi
    PATH="$dir:$PATH"
}

Bunun tek istisnası, bu işlevin PATH öğesine eklenen yolları başka yollarla standartlaştırmamasıdır, bu nedenle bir yol için standart olmayan bir diğer ad PATH içinse, bu bir kopya ekleyecektir. Zaten PATH dizinindeki yolları standartlaştırmaya çalışmak göreceli bir yol prepath 'e aktarıldığında bariz bir anlama sahip olduğundan, zaten yoldayken geçerli çalışma dizininin ne olduğunu bilmiyorsunuz eklendiğinde.

7
cjs

PATH ortam değişkenine yeni bir yol eklemek için:

export PATH=$PATH:/new-path/

Bu değişikliğin açtığınız her Kabuğa uygulanması için, Kabuğun çağrıldığında kaynak göndereceği dosyaya ekleyin. Farklı kabuklarda bu olabilir:

  • Bash Kabuğu: ~/.bash_profile, ~/.bashrc veya profil
  • Korn Shell: ~/.kshrc veya .profile
  • Z Kabuğu: ~/.zshrc veya .zprofile

örneğin.

# export PATH=$PATH:/root/learning/bin/
# source ~/.bashrc
# echo $PATH

Yukarıdaki çıktıda sağlanan yolu görebilirsiniz.

7
Amit24x7

Benim için (Mac OS X 10.9.5'te), yol adını ekleme (ör. /mypathname) /etc/paths çok iyi çalıştı.

Düzenlemeden önce echo $PATH İadeler:

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

Düzenledikten sonra /etc/paths ve Kabuk yeniden başlatıldığında, $ PATH değişkenine /pathname. Aslında, echo $PATH İadeler:

/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin:/mypathname

Ne oldu /mypathname, $PATH değişkeni.

6
faelx

İşte benim çözümüm:

PATH=$(echo -n $PATH | awk -v RS=: -v ORS=: '!x[$0]++' | sed "s/\(.*\).\{1\}/\1/")

İz bırakmayan güzel, kolay bir astar :

5
AJ.