Bash
Interna variabler

Introduktion

Bash interna variabler snabbt

Variabel	detaljer
$* / $@	Funktions- / skriptpositionsparametrar (argument). Expandera enligt följande: $* och $@ är desamma som $1 $2 ... (Observera att det i allmänhet är meningslöst att lämna dem obemärkt) "$*" är samma som "$1 $2 ..." 1 "$@" är samma som "$1" "$2" ... 1. Argument separeras av det första tecknet i $ IFS, vilket inte behöver vara ett mellanslag.
$#	Antal positionsparametrar som skickats till skriptet eller funktionen
$!	Process-ID för det sista (righ-most for pipelines) -kommandot i det senaste jobbet sätts i bakgrunden (notera att det inte nödvändigtvis är detsamma som jobbets processgrupp-ID när jobbkontroll är aktiverat)
$$	ID för processen som utförde bash
$?	Avsluta status för det sista kommandot
$n	Positioneringsparametrar, där n = 1, 2, 3, ..., 9
${n}	Positioneringsparametrar (samma som ovan), men n kan vara> 9
$0	I skript, sökväg som skriptet anropades till; med bash -c 'printf "%s\n" "$0"' name args' : name (det första argumentet efter inline script), annars argv[0] som bash fick.
$_	Sista fältet i det sista kommandot
$IFS	Intern fältavskiljare
$PATH	PATH-miljövariabel som används för att leta upp körbara filer
$OLDPWD	Tidigare arbetskatalog
$PWD	Nuvarande arbetskatalog
$FUNCNAME	Array av funktionsnamn i körsamlingsstacken
$BASH_SOURCE	Array som innehåller källvägar för element i FUNCNAME array. Kan användas för att få skriptvägen.
$BASH_ALIASES	Associativ matris som innehåller alla för närvarande definierade alias
$BASH_REMATCH	Utbud av matcher från den senaste regex-matchen
$BASH_VERSION	Bash-versionsträng
$BASH_VERSINFO	En matris med 6 element med Bash-versioninformation
$BASH	Absolut väg till det nuvarande exekverande Bash-skalet (heuristiskt bestämt av bash baserat på argv[0] och värdet på $PATH ; kan vara fel i hörnfall)
$BASH_SUBSHELL	Bash subshell-nivå
$UID	Verklig (inte effektiv om annan) användar-ID för processen som kör bash
$PS1	Primär kommandoradsprompt; se Använda PS * -variablerna
$PS2	Sekundär kommandoradsprompt (används för ytterligare inmatning)
$PS3	Tertiär kommandoradsprompt (används i väljslinga)
$PS4	Kvarternär kommandoradsprompt (används för att lägga till information med ordinär utgång)
$RANDOM	Ett pseudo slumpmässigt heltal mellan 0 och 32767
$REPLY	Variabel som används som read standard när ingen variabel anges. Används även genom att select att returnera det användarlevererade värdet
$PIPESTATUS	Arrayvariabel som håller utgångsstatusvärdena för varje kommando i den senaste exekverade förgrundsrörledningen.

Variabel tilldelning får inte ha något utrymme före och efter. a=123 inte a = 123 . Det senare (ett lika tecken omgiven av mellanslag) isolerat betyder att kommandot a körs med argumenten = och 123 , även om det också ses i strängjämförelsesoperatören (som syntaktiskt är ett argument till [ eller [[ eller vilket test du än är använder sig av).

$ BASHPID

Process ID (pid) för den nuvarande instansen av Bash. Detta är inte detsamma som $$ variabeln, men det ger ofta samma resultat. Detta är nytt i Bash 4 och fungerar inte i Bash 3.

~> $ echo "\$\$ pid = $$  BASHPID = $BASHPID"
$$ pid = 9265  BASHPID = 9265

$ BASH_ENV

En miljövariabel som pekar på Bash-startfilen som läses när ett skript åberopas.

$ BASH_VERSINFO

En matris som innehåller fullversionsinformation delad i element, mycket bekvämare än $BASH_VERSION om du bara letar efter $BASH_VERSION :

~> $ for ((i=0; i<=5; i++)); do echo "BASH_VERSINFO[$i] = ${BASH_VERSINFO[$i]}"; done
BASH_VERSINFO[0] = 3
BASH_VERSINFO[1] = 2
BASH_VERSINFO[2] = 25
BASH_VERSINFO[3] = 1
BASH_VERSINFO[4] = release
BASH_VERSINFO[5] = x86_64-redhat-linux-gnu

$ BASH_VERSION

Visar versionen av bash som körs, detta gör att du kan bestämma om du kan använda avancerade funktioner:

~> $ echo $BASH_VERSION
4.1.2(1)-release

$ EDITOR

Standardredigeraren som kommer att involveras av alla skript eller program, vanligtvis vi eller emacs.

~> $ echo $EDITOR
vi

$ FUNCNAME

För att få namnet på den aktuella funktionen - skriv:

my_function()
{
    echo "This function is $FUNCNAME"    # This will output "This function is my_function"
}

Denna instruktion returnerar ingenting om du skriver den utanför funktionen:

my_function

echo "This function is $FUNCNAME"    # This will output "This function is"

$ HOME

Användarens hemkatalog

~> $ echo $HOME
/home/user

$ HOSTNAME

Värdnamnet som tilldelats systemet under start.

~> $ echo $HOSTNAME
mybox.mydomain.com

$ HOSTTYPE

Denna variabel identifierar hårdvaran, det kan vara användbart för att bestämma vilka binärer som ska köras:

~> $ echo $HOSTTYPE
x86_64

$ GRUPPER

En matris som innehåller antalet grupper som användaren är i:

#!/usr/bin/env bash
echo You are assigned to the following groups:
for group in ${GROUPS[@]}; do
   IFS=: read -r name dummy number members < <(getent group $group )
   printf "name: %-10s number: %-15s members: %s\n" "$name" "$number" "$members" 
done

$ IFS

Innehåller den interna fältavskiljarsträngen som bash använder för att dela strängar vid looping etc. Standardvärdet är vitrumstecken: \n (ny linje), \t (flik) och mellanslag. Om du ändrar detta till något annat kan du dela strängar med olika tecken:

IFS=","
INPUTSTR="a,b,c,d"
for field in ${INPUTSTR}; do
    echo $field
done 

Utgången från ovanstående är:

a
b
c
d

Anmärkningar:

• Detta är ansvarigt för fenomenet som kallas orddelning .

$ RADNUMMER

Matar ut radnumret i det aktuella skriptet. Mest användbart vid felsökning av skript.

#!/bin/bash
# this is line 2
echo something  # this is line 3
echo $LINENO # Will output 4

$ MACHTYPE

I likhet med $HOSTTYPE ovan inkluderar detta också information om operativsystemet och hårdvara

~> $ echo $MACHTYPE
x86_64-redhat-linux-gnu

$ OLDPWD

OLDPWD ( OLDP rint W orking D irectory) innehåller katalog före det sista cd kommandot:

~> $ cd directory
directory> $ echo $OLDPWD
/home/user

$ OSTYPE

Returnerar information om typen av operativsystem som körs på maskinen, t.ex.

~> $ echo $OSTYPE
linux-gnu

$ PATH

Sökvägen för att hitta binärer för kommandon. Vanliga exempel inkluderar /usr/bin och /usr/local/bin .

När en användare eller skript försöker köra ett kommando söks sökvägarna i $PATH för att hitta en matchande fil med exekveringsbehörighet.

Katalogerna i $PATH är separerade med en : -tecken.

~> $ echo "$PATH"
/usr/kerberos/bin:/usr/local/bin:/bin:/usr/bin

Så, till exempel, med tanke på ovanstående $PATH , om du skriver lss vid prompten, kommer skalet att leta efter /usr/kerberos/bin/lss , sedan /usr/local/bin/lss , sedan /bin/lss , sedan /usr/bin/lss , i den här ordningen, innan du drar slutsatsen att det inte finns något sådant kommando.

$ PPID

Process-ID (pid) för skriptet eller skalets överordnade, vilket betyder processen än åberopat det aktuella skriptet eller skalet.

~> $ echo $$
13016
~> $ echo $PPID
13015

$ PWD

PWD ( P rint W orking D irectory) Den nuvarande arbetskatalogen du befinner dig just nu:

~> $ echo $PWD
/home/user
~> $ cd directory
directory> $ echo $PWD
/home/user/directory

$ SEKUNDER

Antalet sekunder som ett skript har körts. Detta kan bli ganska stort om det visas i skalet:

~> $ echo $SECONDS
98834

$ SHELLOPTS

En readlyly lista över alternativen bash tillhandahålls vid start för att kontrollera dess beteende:

~> $ echo $SHELLOPTS
braceexpand:emacs:hashall:histexpand:history:interactive-comments:monitor

$ SHLVL

När bash-kommandot körs öppnas ett nytt skal. Miljövariabeln $ SHLVL har antalet skalnivåer som det nuvarande skalet kör ovanpå.

I ett nytt terminalfönster ger exekvering av följande kommando olika resultat baserat på Linux-distributionen som används.

echo $SHLVL

Med Fedora 25 är utgången "3". Detta indikerar att när ett nytt skal öppnas, körs en initial bash-kommando och utför en uppgift. Det initiala bash-kommandot kör en underordnad process (ett annat bash-kommando) som i sin tur kör ett sista bash-kommando för att öppna det nya skalet. När det nya skalet öppnas, körs det som en barnprocess av två andra skalprocesser, följaktligen utgången från "3".

I följande exempel (med tanke på att användaren kör Fedora 25) kommer utgången från $ SHLVL i ett nytt skal att ställas in på "3". När varje bash-kommando körs, ökar $ SHLVL med en.

~> $ echo $SHLVL
3
~> $ bash
~> $ echo $SHLVL
4
~> $ bash
~> $ echo $SHLVL
5

Man kan se att exekvering av "bash" -kommandot (eller exekvering av ett bash-skript) öppnar ett nytt skal. Som jämförelse körs ett skript koden i det aktuella skalet.

test1.sh

#!/usr/bin/env bash
echo "Hello from test1.sh. My shell level is $SHLVL"
source "test2.sh"

test2.sh

#!/usr/bin/env bash
echo "Hello from test2.sh. My shell level is $SHLVL"

run.sh

#!/usr/bin/env bash
echo "Hello from run.sh. My shell level is $SHLVL"
./test1.sh

Kör:

chmod +x test1.sh && chmod +x run.sh
./run.sh

Produktion:

Hello from run.sh. My shell level is 4
Hello from test1.sh. My shell level is 5
Hello from test2.sh. My shell level is 5

$ UID

En skrivvariabel som lagrar användarnas ID-nummer:

~> $ echo $UID
12345

$ 1 $ 2 $ 3 osv ...

Positioneringsparametrar som skickas till skriptet från antingen kommandoraden eller en funktion:

#!/bin/bash
# $n is the n'th positional parameter
echo "$1"
echo "$2"
echo "$3"

Utgången från ovanstående är:

~> $ ./testscript.sh firstarg secondarg thirdarg
firstarg
secondarg
thirdarg

Om antalet positionella argument är större än nio måste lockiga hängslen användas.

#  "set -- " sets positional parameters
set -- 1 2 3 4 5 6 7 8 nine ten eleven twelve
# the following line will output 10 not 1 as the value of $1 the digit 1
# will be concatenated with the following 0
echo $10   # outputs 1
echo ${10} # outputs ten
# to show this clearly:
set -- arg{1..12}
echo $10 
echo ${10}

$ #

För att få antalet kommandoradsargument eller positionsparametrar - skriv:

#!/bin/bash
echo "$#"

När du kör med tre argument kommer exemplet ovan att resultera med utdata:

~> $ ./testscript.sh firstarg secondarg thirdarg
3

$ *

Kommer att returnera alla positionsparametrar i en enda sträng.

testscript.sh:

#!/bin/bash
echo "$*"

Kör skriptet med flera argument:

./testscript.sh firstarg secondarg thirdarg 

Produktion:

firstarg secondarg thirdarg

$!

Process-ID (pid) för det senaste jobbet körs i bakgrunden:

~> $ ls &
testfile1 testfile2
[1]+  Done                    ls
~> $ echo $!
21715

$ _

Matar ut det sista fältet från det senaste exekverade kommandot, användbart för att få något att vidarebefordra till ett annat kommando:

 ~> $ ls *.sh;echo $_
testscript1.sh  testscript2.sh
testscript2.sh

---

Den ger skriptvägen om den används före några andra kommandon:

test.sh:

#!/bin/bash
echo "$_"

Produktion:

~> $ ./test.sh # running test.sh
./test.sh

Obs! Detta är inte ett idiotsäkert sätt att få skriptvägen

$?

Utgångsstatus för den senaste exekverade funktionen eller kommandot. Vanligtvis betyder 0 OK något annat kommer att indikera ett fel:

~> $ ls *.blah;echo $?
ls: cannot access *.blah: No such file or directory
2
~> $ ls;echo $?
testfile1 testfile2
0

$$

Process-ID (pid) för den aktuella processen:

~> $ echo $$
13246

$ @

"$@" expanderar till alla kommandoradsargument som separata ord. Det skiljer sig från "$*" , som expanderar till alla argument som ett enda ord.

"$@" Är speciellt användbar för att loopa genom argument och hantering argument med mellanslag.

Tänk på att vi är i ett manus som vi åberopade med två argument, så:

$ ./script.sh "␣1␣2␣" "␣3␣␣4␣"

---

Variablerna $* eller $@ kommer att expandera till $1␣$2 , som i sin tur expanderar till 1␣2␣3␣4 så slingan nedan:

for var in $*; do # same for var in $@; do
    echo \<"$var"\>
done

kommer att skriva ut för båda

<1>
<2>
<3>
<4>

---

Medan "$*" kommer att utvidgas till "$1␣$2" som i sin tur kommer att expandera till "␣1␣2␣␣␣3␣␣4␣" och så slingan:

for var in "$*"; do
    echo \<"$var"\>   
done

kommer endast att åberopa echo gång och kommer att skriva ut

<␣1␣2␣␣␣3␣␣4␣>

---

Och slutligen "$@" kommer att expandera till "$1" "$2" , vilket kommer att expandera till "␣1␣2␣" "␣3␣␣4␣" och så slingan

for var in "$@"; do
    echo \<"$var"\>
done

kommer att skriva ut

<␣1␣2␣>
<␣3␣␣4␣>

därigenom bevaras både det interna avståndet i argumenten och argumentseparationen. Observera att konstruktionen for var in "$@"; do ... är så vanligt och idiomatiskt att det är standard för en för loop och kan förkortas till for var; do ...

$ HISTSIZE

Det maximala antalet ihågkommande kommandon:

~> $ echo $HISTSIZE
1000

$ RANDOM

Varje gång denna parameter refereras genereras ett slumpmässigt heltal mellan 0 och 32767. Tilldela ett värde till denna variabel fröer slumptalsgeneratorn ( källa ).

~> $ echo $RANDOM 
27119
~> $ echo $RANDOM 
1349