Linux-sökväg hur man anger mappsökvägar. PATH miljövariabel. Lägga till användar- och systemmiljövariabler i Linux
När du anger kommandot i kommandorad, säger du i princip åt skalet att köra en körbar fil med ett givet namn. På Linux dessa körbara program, som ls, find, file och andra tenderar att finnas i flera olika kataloger på ditt system. Alla filer med körbara behörigheter lagrade i dessa kataloger kan köras var som helst. De vanligaste katalogerna som innehåller körbara program är /bin, /sbin, /usr/sbin, /usr/local/bin och /usr/local/sbin.
Men hur vet skalet vilka kataloger det ska leta efter körbara program eller hur söker skalet igenom filsystem?
Svaret är enkelt. När du utfärdar ett kommando söker skalet igenom alla kataloger som anges i användarens $PATH-variabel efter en körbar fil med det namnet.
Den här artikeln visar hur du lägger till kataloger till din systemvariabel $PATH.
Vad är $PATH i Linux
Miljövariabeln $PATH är en kolonkoloniserad lista med kataloger som talar om för skalet vilka kataloger som ska söka efter körbara filer.
För att kontrollera vilka kataloger du har i din $PATH-variabel kan du använda kommandot printenv eller echo:
Echo $PATH
Utgången kommer att se ut ungefär så här:
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin
Om du har två körbara filer med samma namn i två olika kataloger kommer skalet att köra filen som finns i katalogen som kommer först i $PATH.
Lägger till en katalog till din $PATH
Det finns situationer där du kanske vill lägga till andra kataloger till din $PATH-variabel. Till exempel kan vissa program installeras på olika platser, eller så kanske du vill ha en dedikerad katalog för dina personliga poster men kunna köra dem utan att ange den absoluta sökvägen till de körbara filerna. För att göra detta behöver du bara lägga till katalogen i din $PATH.
Låt oss säga att du har en katalog som heter bin i din hemkatalog där du lagrar dina skalskript. Så här lägger du till en katalog till din $PATH-variabel:
Exportkommandot exporterar den modifierade variabeln till undermiljöerna för skalprocesserna.
Nu kan du köra dina skript genom att helt enkelt skriva in namnet på det körbara skriptet utan att ange den fullständiga sökvägen till den körbara filen.
Denna ändring är dock tillfällig och påverkar endast den aktuella skalsessionen.
För att göra ändringen permanent måste du definiera en $PATH-variabel i dina skalkonfigurationsfiler. På de flesta Linux-distributioner, när en ny session startas, läses miljövariabler från följande filer:
- Globala skalkonfigurationsfiler som /etc/environment och /etc/profile. Använd den här filen om du vill att den nya katalogen ska läggas till för alla systemanvändare$PATH.
- Konfigurationsfiler för individuella användarskal. Om du till exempel använder Bash kan du ställa in variabeln $PATH i filen ~/.bashrc, och om du använder Zsh är filnamnet ~/.zshrc.
I det här exemplet kommer vi att ställa in en variabel i filen ~/.bashrc. Öppna filen i textredigerare och lägg till följande rad i slutet:
Nano ~/.bashrc
Export PATH="$HOME/bin:$PATH"
Spara filen och ladda det nya $PATH-värdet i den aktuella skalsessionen med:
Källa ~/.bashrc
För att bekräfta att katalogen har lagts till, skriv ut dess $PATH-värde genom att skriva:
Echo $PATH
Slutsats
Att lägga till nya kataloger till din användare eller globala $PATH är ganska enkelt. Detta gör att du kan köra kommandon och skript lagrade på icke-standardiserade platser utan att behöva ange hela sökvägen till den körbara filen.
Samma instruktioner gäller för ev Linux distribution, inklusive , CentOS, RHEL, Debian och Linux Mint.
Lämna gärna en kommentar om du har några frågor.
Vad det är? Många av kommandona du anger vid kommandotolken kräver användning av ett externt program som laddas från filsystemet. Till exempel, kommandon som mkdir och wc finns faktiskt i mappen /bin.
När du anger en instruktion som Bash-skalet inte känner igen, försöker det köra det som ett program och returnerar ett fel om det inte hittar ett program med det namnet. Och detta gäller inte bara de grundläggande kommandona som vi tittade på, för från kommandoraden kan du köra vilket program som helst.
Men hur om det finns en fil Linux-system vet vilka program som ska köras från vilka kataloger? OS använder en systemmiljövariabel för att specificera en delmängd av mappar som ska sökas i när ett okänt kommando tas emot. Denna variabel kallas PATH och kan visas med följande ekokommando (symbolen $ krävs):
Echo $PATH
Utdata från detta kommando kommer att se ut som följande sju absoluta mappsökvägar, separerade med kolon:
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games
Varje gång du anger en okänd Linux-kommandon kommer att titta igenom var och en av mapparna som anges i miljövariabeln i den ordning de specificerades, och försöker hitta ett program med samma namn. Om programmet hittas körs det; annars visas ett felmeddelande. Men det kommer inte att vara ett misstag om du köper dina älskade silverringar som present. Silver kommer att pryda vilken kvinna som helst!
Dessa sju mappar tillhandahåller lätt tillgång till alla större program i operativ system, Inklusive . Alla program utanför dessa sju mappar kan inte startas genom att helt enkelt skriva in deras namn på kommandoraden.
Du laddade till exempel ned dagboksverktyget från Internet till din hemmapp. Om du anger dess namn vid kommandotolken får du ett felmeddelande eftersom det finns i en mapp som inte ingår i systemsökvägen. För att köra detta program, skriv in följande rad (kom ihåg att ~-symbolen är en förkortning för din hemmapp):
Om du har sparat den i en mapp utanför din angivna sökväg måste du ange den absoluta sökvägen och filnamnet för att köra verktyget.
Naturligtvis antas det att diary är ett enkelt fristående program som inte kräver installation, eftersom de flesta större applikationer kommer att placera programmets körbara fil någonstans i din angivna sökväg under installationsprocessen. Så här PATH miljövariabel, njut av det för din hälsa!
export PATH=~/opt/bin:$PATH
Exportera PATH=$PATH:~/opt/bin
9 lösningar samlar in formulärwebb för "Hur lägger man till en sökväg till PATH korrekt?"
Enkla saker
PATH=$PATH:~/opt/bin PATH=~/opt/bin:$PATHberoende på om du vill lägga till ~/opt/bin i slutet (för att söka i alla andra kataloger om det finns ett program med samma namn i flera kataloger) eller i början (för att söka före alla andra kataloger).
Du kan lägga till flera poster samtidigt. PATH=$PATH:~/opt/bin:~/opt/node/bin eller ändringar i beställningen är bra.
Du behöver inte exportera om variabeln redan finns i miljön: varje förändring av variabelns värde återspeglas i miljön.PATH finns nästan alltid i miljön; Allt unix-system installera det väldigt tidigt (vanligtvis i den allra första processen faktiskt).
Om din PATH är inbyggd i olika komponenter kan du sluta med dubbla poster. Se Hur man lägger till sökvägen till källkatalogen som ska upptäckas av Unix, vad är kommandot? och ta bort dubbletter av $PATH-poster med awk-kommandot för att undvika att lägga till dubbletter eller ta bort dem.
Var man ska lägga
Observera att ~/.bash_rc inte är läsbar av något program, och ~/.bashrc är konfigurationsfilen för interaktiva bash-instanser. Du bör inte definiera miljövariabler i ~/.bashrc. Den korrekta platsen för att definiera miljövariabler som PATH är ~/.profile (eller ~/.bash_profile om du inte behöver icke-bash-skal). Se vad som är skillnaden mellan dem och vilken ska jag använda?
Anteckningar om icke-bash skal
I bash, ksh och zsh är export en speciell syntax, och både PATH=~/opt/bin:$PATH och export PATH=~/opt/bin:$PATH gör allt rätt. På andra Bourne/POSIX-skal som dash (som är /bin/sh på många system), tolkas export som ett vanligt kommando, vilket innebär två skillnader:
- ~ tolkas bara i början av ett ord, förutom i tilldelningar (se avsnittet "Hur man lägger till en sökväg till en källkatalog som kommer att upptäckas av Unix, vilket kommando?").
- $PATH utanför dubbla citattecken bryter om PATH innehåller mellanslag eller \[*? ,
Så i streckliknande skal, export PATH=~/opt/bin:$PATH ställer PATH till den bokstavliga strängen ~/opt/bin/: följt av värdet för PATH upp till första platsen. PATH=~/opt/bin:$PATH (fuzzy assignment) kräver inga citat och gör det rätta. Om du vill använda export i ett bärbart skript måste du skriva export PATH="$HOME/opt/bin:$PATH" .
¹ Detta var inte sant i Bourne-raketer (som i det riktiga Bourne-skalet, inte moderna POSIX-skal), men det är osannolikt att du kommer att stöta på skal som är så gamla nuförtiden.
Det fungerar ändå, men de gör inte samma sak: PATH-element kontrolleras från vänster till höger. I det första exemplet körbara filer i ~/opt/bin kommer att ha företräde framför de som är installerade i t ex /usr/bin , som kanske är vad du vill ha eller inte.
Särskilt ur ett säkerhetsperspektiv är det farligt att lägga till sökvägar till fronten, för om någon kan få skrivåtkomst till din ~/opt/bin , kan de till exempel placera andra ls som du "då förmodligen skulle använda istället för / bin/ls utan att märka Föreställ dig nu samma sak som för ssh eller din webbläsare eller val... (Samma sak kan göras tre gånger i din väg.)
Jag är förvirrad av fråga 2 (eftersom den togs bort från frågan eftersom den var relaterad till ett icke-relaterat problem):
Vad effektiv metod lägga till ytterligare sökvägar till olika linjer? Först tänkte jag att det här kan göra susen:
Export PATH=$PATH:~/opt/bin export PATH=$PATH:~/opt/node/bin
men det gör det inte eftersom den andra tilldelningen inte bara lägger till ~/opt/node/bin utan även alla tidigare tilldelade PATH .
Detta är en möjlig lösning:
Export PATH=$PATH:~/opt/bin:~/opt/node/bin
men för läsbarheten vill jag hellre ha en destination per väg.
Om du säger
PATH=~/opt/bin
Detta Allt, vad kommer att vara i din VÄG. PATH är bara en miljövariabel, och om du vill lägga till i PATH måste du bygga om variabeln med exakt det innehåll du vill ha. Så det du ger som exempel i fråga 2 är precis vad du vill göra, såvida jag inte helt missar poängen med frågan.
Jag använder båda formerna i min kod. Jag har en allmän profil som jag installerar på varje dator jag arbetar på som ser ut så här för att ta emot potentiellt saknade kataloger:
Export PATH=/opt/bin:/usr/local/bin:/usr/contrib/bin:/bin:/usr/bin:/usr/sbin:/usr/bin/X11 # lägg till valfria objekt till sökvägen för bindir i $HOME/local/bin $HOME/bin; gör om [ -d $bindir ]; sedan PATH=$PATH:$(bindir) fi klar
Linux bestämmer den körbara sökvägen från $PATH-miljön. För att lägga till katalogen /data/myscripts till toppen av $PATH-miljön, använd följande:
PATH=/data/myscripts:$PATH
För att lägga till den här katalogen i slutet av sökvägen, använd följande kommando:
PATH=$PATH:/data/myscripts
Men de tidigare räcker inte för när du ställer in en miljövariabel i ett skript, träder den ändringen bara i kraft inuti skriptet. Denna begränsning är begränsad på bara två sätt:
- Om du exporterar en miljövariabel i ett skript är den effektiv i alla program som anropas av skriptet. Observera att detta inte är effektivt i ett program som kallas skript.
- Om programmet som anropar skriptet gör det genom att inkludera istället för att anropa, är alla miljöändringar i skriptet effektiva på det anropande programmet. Denna inkludering kan göras med hjälp av dot-kommandot eller source-kommandot.
$HOME/myscript.sh källa $HOME/myscript.sh
Inkludering inkluderar i princip det "anropsbara" skriptet i "call"-skriptet. Detta liknar #include i C. Så det är effektivt i ett skript eller ett anropsprogram. Men detta är naturligtvis inte effektivt för några program eller skript som anropas av det anropande programmet. För att göra det effektivt ner till anropskedjan måste du följa miljövariabelinställningen med hjälp av exportkommandot.
Som ett exempel inkluderar bash-skalprogrammet innehållet i .bash_profile-filen genom inkludering. Så, lägg till följande två rader till .bash_profile:
PATH=$PATH:/data/myscripts export PATH
sätter effektivt in dessa två rader kod i ett bash-program. Alltså i bash variabel$PATH inkluderar $HOME/myscript.sh , och på grund av exportsatsen kommer alla program som anropas av bash att ha $PATH modifierade. Och eftersom alla program som startas från bash-prompten anropas av bash, är den nya sökvägen giltig för allt du startar från bash-prompten.
Summan av kardemumman är att för att lägga till en ny katalog till sökvägen måste du lägga till eller lägga till katalogen till miljövariabeln $PATH i ett skript som ingår i skalet, och du måste exportera miljövariabeln $PATH.
Under en tid har jag haft med mig två funktioner pathadd och pathrm som hjälper till att lägga till element till en sökväg utan att behöva oroa sig för dupliceringar.
pathadd tar ett sökvägsargument och ett valfritt efterargument som om det läggs till kommer att läggas till PATH annars kommer det att läggas till det.
I nästan alla situationer, om du lägger till en sökväg, vill du förmodligen åsidosätta allt som redan finns i sökvägen, så jag föredrar att lägga till som standard.
Pathadd() ( newelement=$(1%/) if [ -d "$1" ] && ! echo $PATH | grep -E -q "(^|:)$newelement($|:)" ; sedan om [ " $2" = "efter" ] ; sedan 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")" )
Placera dem i valfritt skript du vill ändra PATH-miljön och du kan nu göra det.
Pathadd "/foo/bar" pathadd "/baz/bat" efter export PATH
Du kommer garanterat inte att lägga till en sökväg om den redan finns. Om du nu vill att /baz/bat ska vara vid start.
Pathrm "/baz/bat" pathadd "/baz/bat" export PATH
Vilken bana som helst kan nu föras till fronten om den redan är på en bana utan fördubbling.
Jag kan inte tala för andra distributioner, men Ubuntu har en fil, /etc/environment, som är standardsökvägen för alla användare. Eftersom min dator bara används av mig lägger jag vilka kataloger jag vill i min väg, så länge det är ett tillfälligt tillägg som jag lägger in i skriptet.
Här är min lösning:
PATH=$(echo -n $PATH | awk -v RS=: -v ORS=: "!x[$0]++" | sed "s/\(.*\).\(1\)/\1 /")
Snyggt lätt foder som inte lämnar släp:
För mig (på Mac OS X 10.9.5) fungerade det mycket bra att lägga till sökvägsnamnet (t.ex. /mypathname) till filen /etc/paths.
Innan redigering returneras echo $PATH:
/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin
Efter att ha redigerat /etc/paths och startat om skalet läggs variabeln $PATH till med /pathname . Faktum är att echo $PATH returnerar:
/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin:/mypathname
Det som hände var att /mypathname lades till $PATH .
Så här lägger du till en ny sökväg till PATH-miljön PATH:
Exportera PATH=$PATH:/new-path/
För att få denna ändring att gälla för varje skal du öppnar, lägg till det i en fil som skalet kommer att anropa när du anropar det. I olika skal kan detta vara:
- Bash Shell: ~/.bash_profile, ~/.bashrc eller profile
- Korn Shell: ~/.kshrc eller .profile
- Z Shell: ~/.zshrc eller .zprofile
Till exempel
# export PATH=$PATH:/root/learning/bin/ # source ~/.bashrc # echo $PATH
Du kan se den angivna sökvägen i utgången ovan.
Alla filer i Linux har en specifik adress i filsystemet med vilken vi kan komma åt dem med hjälp av en filhanterare eller konsolverktyg. Detta är ett ganska enkelt ämne, men många nybörjare har svårt med det.
I dagens korta artikel ska vi titta på vad sökvägen till en Linux-fil är, vad den kan vara, hur man skriver den korrekt och mycket mer. Om du hade problem med detta tidigare, kommer allt att bli helt klart efter att ha läst artikeln.
Filsökvägar i Linux
Linux-filsystemet skiljer sig mycket från Windows. Vi kommer inte att överväga dess struktur, det gjordes tidigare. Vi kommer att fokusera på att arbeta med filer.
Den viktigaste skillnaden är att filadressen inte startar från enheten, till exempel C:\ eller D:\ som det händer i Windows, utan från roten, rotsystemkatalogen som alla andra är anslutna till. Hans adress - /. Och här måste vi prata om adresser. Linux-filsökvägar använder snedstreck "/" för att separera kataloger i adressen, och detta skiljer sig från vad du är van vid att se i Windows - \.
Till exempel om i Fönstren är fulla sökvägen till filen på skrivbordet såg ut som C:\Users\Sergiy\Desktop\, då skulle filsökvägen i Linux helt enkelt vara /home/sergiy/desktop/. Med detta är allt enkelt och tydligt än så länge. Men problem uppstår ytterligare.
I operativsystemet Linux kan det finnas flera typer av filsökvägar. Låt oss titta på vilka vägar det finns i Linux:
- Fullständig, absolut linux-sökväg från filsystemets rot- du har redan sett den här sökvägen i exemplet ovan, den börjar från roten "/" och beskriver hela sökvägen till filen;
- Linux relativ väg- detta är sökvägen till filen i förhållande till den aktuella mappen; sådana sökvägar orsakar ofta förvirring.
- Sökväg i förhållande till den aktuella användarens hemmapp.- sökväg i filsystemet, men inte från roten, utan från den aktuella användarens mapp.
Låt oss nu ta en närmare titt på hur dessa vägar ser ut i Linux, och titta även på några exempel för att göra det helt klart. För demonstrationen kommer vi att använda verktyget ls, som är utformat för att se innehållet i kataloger.
Till exempel har vi en katalog som denna i vår hemmapp med fyra filer i den:
Så här kommer den fullständiga Linux-sökvägen till en av filerna att se ut:
ls /home/sergiy/tmp/fil1
Detta är redan en relativ Linux-sökväg, som börjar från hemmappen, den är betecknad ~/. Notera, inte ~, nämligen ~/. Sedan kan du ange undermappar, i vårt fall tmp:
Tja, eller filsökvägen i Linux, i förhållande till den aktuella mappen:
Den första länken pekar på den aktuella mappen (.), den andra (..) pekar på en högre mapp. Detta öppnar upp för ännu större möjligheter för katalognavigering. Till exempel, för att referera till en fil i den aktuella mappen kan du använda följande konstruktion:
Detta är till ingen nytta när du tittar på innehållet i en fil. Men det är väldigt viktigt när man kör programmet. Eftersom programmet först kommer att sökas i PATH-miljön, och först sedan i den här mappen. Därför, om du behöver köra ett program som finns i den aktuella mappen och det heter exakt samma som det i /bin-katalogen, behöver du utan en explicit länk leta efter filen i den aktuella mappen, ingenting kommer att fungera.
Sådana konstruktioner kan förekomma ganska ofta när man kompilerar program. Du kan använda alla dessa symboler och linux-filsökvägar, inte bara i terminalen utan också i vilken som helst filhanterare, vilket kan vara väldigt bekvämt.
Men Linux terminal ger ännu större möjligheter. Du kan använda enkla jokertecken direkt i fil- eller katalogadresser. Till exempel kan du lista alla filer som börjar med f:
Eller så kan du till och med söka inte bara i tmp-mappen, utan i vilken undermapp som helst i din hemmapp:
Och allt detta kommer att fungera, kanske är det inte alltid nödvändigt och praktiskt. Men i vissa situationer kan det hjälpa mycket. Dessa funktioner är implementerade på Bash-skalnivån, så du kan använda dem i alla kommandon. Skalet tittar på hur många filer som hittades och anropar ett kommando för var och en av dem.
Slutsatser
Det är allt. Nu vet du allt du behöver för att inte bara skriva vägen till korrekt linux-fil, men utför också mer komplexa åtgärder, som att söka efter filer eller navigera genom kataloger med kommandot cd. Om du har några frågor, fråga i kommentarerna!
Relaterade inlägg:
Jag undrar var den nya sökvägen ska läggas till i miljövariabeln PATH. Jag vet att detta kan åstadkommas genom att redigera .bashrc (till exempel), men det är inte klart hur man gör detta.
Således:
Exportera PATH=~/opt/bin:$PATH
Exportera PATH=$PATH:~/opt/bin
11 svar
Enkelt material
PATH=$PATH:~/opt/bin PATH=~/opt/bin:$PATHberoende på om du vill lägga till ~/opt/bin-koden i slutet (för att söka i alla andra kataloger om det finns ett program med samma namn i flera kataloger) eller i början (för att söka före alla andra kataloger).
Du kan lägga till flera poster samtidigt. PATH=$PATH:~/opt/bin:~/opt/node/bin eller ändringar i beställningen är bra.
Du behöver inte exportera om variabeln redan finns i miljön: varje förändring av variabelns värde återspeglas i miljön.¹ PATH finns i stort sett alltid i miljön; alla unix-system installerar det väldigt tidigt (vanligtvis i den allra första processen faktiskt).
Om din PATH skapas av många olika komponenter kan du sluta med dubbla poster. Se Hur man lägger till en sökväg till din hemkatalog som kommer att upptäckas av Unix, vilket kommando? och Ta bort dubbletter av $PATH-poster med kommandot awk för att undvika dubbletter eller ta bort dem.
Var man ska lägga
Observera att ~/.bash_rc inte är läsbar av något program, och ~/.bashrc är konfigurationsfilen för interaktiva bash-instanser. Du bör inte definiera miljövariabler i ~/.bashrc. Den korrekta platsen för att definiera miljövariabler som PATH är ~/.profile (eller ~/.bash_profile om du inte gillar andra skal än bash). Se Vad är skillnaden mellan dem och vilken ska jag använda?
Anteckningar om icke-bash skal
I bash, ksh och zsh är export en speciell syntax, och både PATH=~/opt/bin:$PATH och export PATH=~/opt/bin:$PATH gör rätt till och med. På andra Bourne/POSIX-skal, som dash (som är /bin/sh på många system), tolkas export som ett vanligt kommando, vilket innebär två skillnader:
- ~ tolkas bara i början av ett ord, förutom i tilldelningar (se Hur lägger jag till en hemkatalogsökväg som kommer att upptäckas av Unix som kräver kommandot? ;
- $PATH extern dubbla citattecken bryter om PATH innehåller mellanslag eller \[*? .
Så, i skal som bindestreck, export PATH=~/opt/bin:$PATH ställer PATH till den bokstavliga strängen ~/opt/bin/: följt av PATH-värdet upp till första platsen. PATH=~/opt/bin:$PATH (enkel uppgift) kräver inga citat och gör allt rätt. Om du vill använda export i ett bärbart skript måste du skriva export PATH="$HOME/opt/bin:$PATH" eller PATH=~/opt/bin:$PATH export PATH (eller PATH=$HOME/opt /bin: $PATH export PATH för portabilitet även till Bourne-skalet, som inte accepterar export var=värde och inte gjorde tilde-expansion).
¹ Detta var inte sant i Bourne-skalen (som i det faktiska Bourne-skalet, inte moderna skal i POSIX-stil), men det är osannolikt att du kommer att stöta på skal som är så gamla nuförtiden. Sub>
Hur som helst fungerar, men de gör inte samma sak: PATH-element kontrolleras från vänster till höger. I det första exemplet kommer körbara filer i ~/opt/bin att ha företräde framför de som är installerade i till exempel /usr/bin , vilket kanske är det du vill ha eller inte.
Speciellt är det farligt ur ett säkerhetsperspektiv att lägga till sökvägar till fronten, för om någon kan få skrivåtkomst till din ~/opt/bin , kan de till exempel lägga en annan ls, som du förmodligen kommer att använda istället /bin/ls utan att märka det. Föreställ dig nu samma sak för ssh eller din webbläsare eller val... (Samma sak tre gånger på din väg.)
Jag är förvirrad angående fråga 2 (eftersom den togs bort från frågan eftersom den var relaterad till inte relaterat problem):
Vad är ett effektivt sätt att lägga till ytterligare vägar till olika linjer? Först tänkte jag att det här kan göra susen:
Export PATH=$PATH:~/opt/bin export PATH=$PATH:~/opt/node/bin
Men det beror inte på att den andra tilldelningen inte bara lägger till ~/opt/node/bin utan även den tidigare tilldelade PATH .
Detta är en möjlig lösning:
Export PATH=$PATH:~/opt/bin:~/opt/node/bin
Men för läsbarheten vill jag hellre ha en destination per väg.
Om du säger
PATH=~/opt/bin
Detta Allt, som kommer att vara i din PÅGÅNG. PATH är bara en miljövariabel, och om du vill lägga till i PATH måste du bygga om variabeln med exakt det innehåll du vill ha. Dvs det du ger som exempel i fråga 2 är precis vad du vill göra, om jag inte helt missat poängen med frågan.
Jag använder båda formerna i min kod. Jag har en allmän profil som jag installerar på varje maskin jag arbetar på som ser ut så här, för att vara värd för potentiellt saknade kataloger:
Export PATH=/opt/bin:/usr/local/bin:/usr/contrib/bin:/bin:/usr/bin:/usr/sbin:/usr/bin/X11 # lägg till valfria objekt till sökvägen för bindir i $HOME/local/bin $HOME/bin; gör om [ -d $bindir ]; sedan PATH=$PATH:$(bindir) fi klar
Linux definierar den körbara sökvägen med miljövariabeln $PATH. För att lägga till katalogen /data/myscripts i början av miljövariabeln $PATH, använd följande:
PATH=/data/myscripts:$PATH
För att lägga till den här katalogen i slutet av sökvägen, använd följande kommando:
PATH=$PATH:/data/myscripts
Men de tidigare räcker inte för när du ställer in en miljövariabel i ett skript, träder den ändringen bara i kraft inuti skriptet. Denna begränsning är begränsad på två sätt:
- Om du exporterar en miljövariabel i ett skript är den effektiv i alla program som anropas av skriptet. Observera att detta inte är effektivt i programmet som anropade skriptet.
- Om programmet som anropar skriptet gör det genom att inkludera istället för att anropa, är alla miljöändringar i skriptet effektiva på det anropande programmet. Denna inkludering kan göras med hjälp av dot-kommandot eller source-kommandot.
$HOME/myscript.sh källa $HOME/myscript.sh
Inkludering inkluderar i princip det "anropsbara" skriptet i "call"-skriptet. Detta liknar #include i C. Så det är effektivt i ett skript eller ett anropsprogram. Men detta är naturligtvis inte effektivt för några program eller skript som anropas av det anropande programmet. För att göra det effektivt ner till anropskedjan måste du följa miljövariabelinställningen med hjälp av exportkommandot.
Som ett exempel inkluderar bash-skalprogrammet innehållet i .bash_profile-filen genom inkludering. Så lägg följande två rader i .bash_profile:
PATH=$PATH:/data/myscripts export PATH
sätter effektivt in dessa två rader kod i ett bash-program. Så i bash inkluderar variabeln $PATH $HOME/myscript.sh, och på grund av exportsatsen har alla program som anropas av bash variabeln $PATH modifierad. Och eftersom alla program du startar från bash-prompten anropas av bash, gäller den nya sökvägen för allt du startar från bash-prompten.
Summan av kardemumman är att för att lägga till en ny katalog till sökvägen måste du lägga till eller lägga till katalogen till miljövariabeln $PATH i ett skript som ingår i skalet, och du måste exportera miljövariabeln $PATH.
Jag har haft med mig under en tid två funktioner pathadd och pathrm som hjälper till att lägga till element till en sökväg utan att oroa dig för dupliceringar.
pathadd tar ett sökvägsargument och ett valfritt efterargument, som om det läggs till kommer att läggas till PATH , annars kommer det att läggas till det.
I alla situationer, om du lägger till en sökväg, vill du förmodligen åsidosätta allt som redan finns i sökvägen, så jag föredrar att lägga till som standard.
Pathadd() ( newelement=$(1%/) if [ -d "$1" ] && ! echo $PATH | grep -E -q "(^|:)$newelement($|:)" ; sedan om [ " $2" = "efter" ] ; sedan 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")" )
Placera dem i vilket skript du vill för att ändra PATH-miljön och du är nu klar.
Pathadd "/foo/bar" pathadd "/baz/bat" efter export PATH
Du kommer garanterat inte att lägga till en sökväg om den redan finns. Om du vill att /baz/bat ska köras först.
Pathrm "/baz/bat" pathadd "/baz/bat" export PATH
Vilken bana som helst kan nu flyttas framåt om den redan är på en bana utan att fördubblas.
Skottsäker tillsats/förberedningsmetod
Det finns många överväganden involverade i att välja att lägga till och lägga till. Många av dem tas upp i andra svar, så jag kommer inte att upprepa dem här.
Den viktiga punkten är att även om systemskripten inte använder detta (jag undrar varför) *1, så är det ett skottsäkert sätt att lägga till en sökväg (t.ex. $HOME/bin) till PATH miljövariabeln
PATH="$(PATH:+$(PATH):)$HOME/bin"
att lägga till (istället för PATH="$PATH:$HOME/bin") och
PATH="$HOME/bin$(PATH:+:$(PATH))"
att lägga till (istället för PATH="$HOME/bin:$PATH")
Detta undviker en falsk ledande/släpande kolon när $PATH initialt är tom, vilket kan ha oönskade biverkningar och kan vara en mardröm att hitta (det här svaret tar kortfattat upp det obehagliga fallet).
$(parameter:+ord)Om parametern är null eller inställd ersätts ingenting, annars ersätts den ord ord.
Så $(PATH:+$(PATH):) expanderar till: 1) ingenting om PATH är null eller inställt, 2) $(PATH): om PATH är inställt.
Notera. Det här är för bash.
*1 Jag upptäckte precis att skript som devtoolset-6/enable använder detta, $ cat /opt/rh/devtoolset-6/enable # Allmänna miljövariabler export PATH=/opt/rh/devtoolset-6/root/usr /bin $(PATH:+:$(PATH)) ...
Jag kan inte tala för andra distributioner, men Ubuntu har en fil, /etc/environment, som är standardsökvägen för alla användare. Eftersom min dator bara används av mig lägger jag in de kataloger jag vill ha i min väg där om det inte är ett tillfälligt tillägg jag lägger in i skriptet.
För mig (på Mac OS X 10.9.5) fungerade det mycket bra att lägga till sökvägsnamnet (t.ex. /mypathname) till filen /etc/paths.
Innan redigering returneras echo $PATH:
/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin
Efter att ha redigerat /etc/paths och startat om skalet läggs variabeln $PATH till med /pathname . Faktum är att echo $PATH returnerar:
/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin:/mypathname
Det som hände var att /mypathname lades till i variabeln $PATH.
