Bash
Interne variabelen

Invoering

Bash interne variabelen in één oogopslag

veranderlijk	Details
$* / $@	Functie / script positionele parameters (argumenten). Vouw als volgt uit: $* en $@ zijn hetzelfde als $1 $2 ... (merk op dat het in het algemeen geen zin heeft om die niet te vermelden) "$*" is hetzelfde als "$1 $2 ..." 1 "$@" is hetzelfde als "$1" "$2" ... 1. Argumenten worden gescheiden door het eerste teken van $ IFS, dat geen spatie hoeft te zijn.
$#	Aantal positionele parameters dat is doorgegeven aan het script of de functie
$!	Proces-ID van de laatste (meest geschikte voor pijpleidingen) opdracht in de meest recent op de achtergrond geplaatste opdracht (merk op dat dit niet noodzakelijkerwijs hetzelfde is als de procesgroep-ID van de opdracht wanneer opdrachtbeheer is ingeschakeld)
$$	ID van het proces dat bash uitgevoerd
$?	Status van het laatste commando verlaten
$n	Positieparameters, waarbij n = 1, 2, 3, ..., 9
${n}	Positieparameters (hetzelfde als hierboven), maar n kan> 9 zijn
$0	In scripts, pad waarmee het script werd aangeroepen; met bash -c 'printf "%s\n" "$0"' name args' : name (het eerste argument na het inline script), anders de argv[0] die bash ontving.
$_	Laatste veld van de laatste opdracht
$IFS	Intern veldscheidingsteken
$PATH	PATH omgevingsvariabele gebruikt om uitvoerbare bestanden op te zoeken
$OLDPWD	Vorige werkmap
$PWD	Huidige werkmap
$FUNCNAME	Array van functienamen in de uitvoeringsoproepstapel
$BASH_SOURCE	Matrix met FUNCNAME voor elementen in FUNCNAME array. Kan worden gebruikt om het scriptpad te krijgen.
$BASH_ALIASES	Associatieve array met alle momenteel gedefinieerde aliassen
$BASH_REMATCH	Array van wedstrijden van de laatste regex-wedstrijd
$BASH_VERSION	Bash-versiereeks
$BASH_VERSINFO	Een array van 6 elementen met Bash-versie-informatie
$BASH	Absoluut pad naar de momenteel uitgevoerde Bash-shell zelf (heuristisch bepaald door bash basis van argv[0] en de waarde van $PATH ; kan verkeerd zijn in hoekgevallen)
$BASH_SUBSHELL	Basniveau subschaal
$UID	Real (niet effectief indien anders) Gebruikers-ID van het bash proces
$PS1	Primaire opdrachtregelprompt; zie Gebruik van de PS * -variabelen
$PS2	Secundaire opdrachtregelprompt (gebruikt voor extra invoer)
$PS3	Tertiaire opdrachtregelprompt (gebruikt in select loop)
$PS4	Quaternaire opdrachtregelprompt (gebruikt om info toe te voegen met uitgebreide uitvoer)
$RANDOM	Een pseudo-willekeurig geheel getal tussen 0 en 32767
$REPLY	Variabele wordt standaard gebruikt door read als er geen variabele is opgegeven. Wordt ook gebruikt door select om de door de gebruiker opgegeven waarde te retourneren
$PIPESTATUS	Matrixvariabele die de exitstatuswaarden van elke opdracht in de laatst uitgevoerde voorgrondpijplijn bevat.

Variabele toewijzing mag voor en na geen spatie bevatten. a=123 niet a = 123 . De laatste (een gelijkteken omgeven door spaties) betekent afzonderlijk dat het commando a met de argumenten = en 123 , hoewel het ook wordt gezien in de stringvergelijkingsoperator (wat syntactisch een argument is voor [ of [[ of welke test je ook bent) gebruik makend van).

$ BASHPID

Proces-ID (pid) van de huidige instantie van Bash. Dit is niet hetzelfde als de variabele $$ , maar het geeft vaak hetzelfde resultaat. Dit is nieuw in Bash 4 en werkt niet in Bash 3.

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

$ BASH_ENV

Een omgevingsvariabele die verwijst naar het Bash-opstartbestand dat wordt gelezen wanneer een script wordt aangeroepen.

$ BASH_VERSINFO

Een array met de volledige versie-informatie opgesplitst in elementen, veel handiger dan $BASH_VERSION als u alleen op zoek bent naar de hoofdversie:

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

Toont de versie van bash die wordt uitgevoerd, hiermee kunt u beslissen of u geavanceerde functies kunt gebruiken:

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

$ EDITOR

De standaardeditor die wordt betrokken bij scripts of programma's, meestal vi of emacs.

~> $ echo $EDITOR
vi

$ FUNCNAME

Typ het volgende om de naam van de huidige functie te krijgen:

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

Deze instructie retourneert niets als u deze buiten de functie typt:

my_function

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

$ HOME

De thuismap van de gebruiker

~> $ echo $HOME
/home/user

$ HOSTNAME

De hostnaam die tijdens het opstarten aan het systeem is toegewezen.

~> $ echo $HOSTNAME
mybox.mydomain.com

$ HOSTTYPE

Deze variabele identificeert de hardware, het kan nuttig zijn om te bepalen welke binaire bestanden moeten worden uitgevoerd:

~> $ echo $HOSTTYPE
x86_64

$ GROEPEN

Een array met het aantal groepen waarin de gebruiker zich bevindt:

#!/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

Bevat de interne veldscheidingstekenreeks die bash gebruikt om tekenreeksen te splitsen tijdens het doorlussen, enz. De standaard is de witruimte-tekens: \n (nieuwe regel), \t (tab) en spatie. Door dit in iets anders te veranderen, kun je strings splitsen met verschillende karakters:

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

De output van het bovenstaande is:

a
b
c
d

Opmerkingen:

• Dit is verantwoordelijk voor het fenomeen dat woordsplitsing wordt genoemd .

$ REGELNR

Voert het regelnummer uit in het huidige script. Vooral handig bij het debuggen van scripts.

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

$ MACHTYPE

Vergelijkbaar met $HOSTTYPE hierboven, bevat dit ook informatie over het besturingssysteem en hardware

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

$ OLDPWD

OLDPWD ( OLDP rint W orking D irectory) bevat een map vóór de laatste cd opdracht:

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

$ OSTYPE

Retourneert informatie over het type besturingssysteem dat op de computer wordt uitgevoerd, bijvoorbeeld.

~> $ echo $OSTYPE
linux-gnu

$ PATH

Het zoekpad voor het vinden van binaire bestanden voor opdrachten. Veel voorkomende voorbeelden zijn /usr/bin en /usr/local/bin .

Wanneer een gebruiker of script een opdracht probeert uit te voeren, worden de paden in $PATH doorzocht om een overeenkomend bestand te vinden met uitvoeringsmachtiging.

De mappen in $PATH worden gescheiden door een : -teken.

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

Dus, gegeven de bovenstaande $PATH , lss u, als u lss bij de prompt typt, naar /usr/kerberos/bin/lss , vervolgens /usr/local/bin/lss , dan /bin/lss en vervolgens /usr/bin/lss , in deze volgorde, voordat wordt geconcludeerd dat er geen dergelijke opdracht is.

$ PPID

De proces-ID (pid) van het bovenliggende script of shell, wat betekent dat het proces vervolgens het huidige script of shell heeft aangeroepen.

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

$ PWD

PWD ( P rint W orking D irectory) De huidige werkmap waarin u zich momenteel bevindt:

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

$ SECONDS

Het aantal seconden dat een script is uitgevoerd. Dit kan behoorlijk groot worden als het in de shell wordt weergegeven:

~> $ echo $SECONDS
98834

$ SHELLOPTS

Een alleen-lezen lijst van de opties bash wordt bij het opstarten geleverd om het gedrag te regelen:

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

$ SHLVL

Wanneer het bash-commando wordt uitgevoerd, wordt een nieuwe shell geopend. De omgevingsvariabele $ SHLVL bevat het aantal shell-niveaus waarop de huidige shell wordt uitgevoerd.

In een nieuw terminalvenster zal het uitvoeren van de volgende opdracht verschillende resultaten opleveren op basis van de gebruikte Linux-distributie.

echo $SHLVL

Met Fedora 25 is de output "3". Dit geeft aan dat bij het openen van een nieuwe shell een initiële bash-opdracht een taak uitvoert en uitvoert. Het initiële bash-commando voert een kindproces uit (een ander bash-commando) dat op zijn beurt een laatste bash-commando uitvoert om de nieuwe shell te openen. Wanneer de nieuwe shell wordt geopend, wordt deze uitgevoerd als een onderliggend proces van 2 andere shell-processen, vandaar de uitvoer van "3".

In het volgende voorbeeld (gegeven dat de gebruiker Fedora 25 gebruikt), zal de uitvoer van $ SHLVL in een nieuwe shell worden ingesteld op "3". Terwijl elke bash-opdracht wordt uitgevoerd, wordt $ SHLVL met één verhoogd.

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

Je kunt zien dat het uitvoeren van de opdracht 'bash' (of het uitvoeren van een bash-script) een nieuwe shell opent. Ter vergelijking: bij het uitvoeren van een script wordt de code in de huidige shell uitgevoerd.

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

uitvoeren:

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

Output:

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

Een alleen-lezen variabele die het ID-nummer van de gebruiker opslaat:

~> $ echo $UID
12345

$ 1 $ 2 $ 3 enz ...

Positieparameters die aan het script zijn doorgegeven via de opdrachtregel of een functie:

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

De output van het bovenstaande is:

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

Als het aantal positionele argumenten groter is dan negen, moeten accolades worden gebruikt.

#  "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}

$ #

Typ het volgende om het aantal opdrachtregelargumenten of positionele parameters te krijgen:

#!/bin/bash
echo "$#"

Bij uitvoering met drie argumenten resulteert het bovenstaande voorbeeld in de uitvoer:

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

$ *

Retourneert alle positionele parameters in een enkele string.

testscript.sh:

#!/bin/bash
echo "$*"

Voer het script uit met verschillende argumenten:

./testscript.sh firstarg secondarg thirdarg 

Output:

firstarg secondarg thirdarg

$!

De proces-ID (pid) van de laatste taak die op de achtergrond is uitgevoerd:

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

$ _

Voert het laatste veld van de laatst uitgevoerde opdracht uit, handig om iets door te geven aan een andere opdracht:

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

---

Het geeft het scriptpad als het vóór andere opdrachten wordt gebruikt:

test.sh:

#!/bin/bash
echo "$_"

Output:

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

Opmerking: dit is geen onfeilbare manier om het scriptpad te krijgen

$?

De exitstatus van de laatst uitgevoerde functie of opdracht. Meestal betekent 0 OK, anders duidt een fout op:

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

$$

De proces-ID (pid) van het huidige proces:

~> $ echo $$
13246

$ @

"$@" uitgebreid naar alle opdrachtregelargumenten als afzonderlijke woorden. Het verschilt van "$*" , dat alle argumenten als een enkel woord uitbreidt.

"$@" is met name handig voor het doorlopen van argumenten en het afhandelen van argumenten met spaties.

Overweeg dat we ons in een script bevinden dat we met twee argumenten hebben aangeroepen, zoals:

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

---

De variabelen $* of $@ worden uitgebreid naar $1␣$2 , die op hun beurt weer uitbreiden naar 1␣2␣3␣4 dus de onderstaande lus:

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

wordt voor beide afgedrukt

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

---

Terwijl "$*" zal worden uitgebreid naar "$1␣$2" wat op zijn beurt zal uitbreiden naar "␣1␣2␣␣␣3␣␣4␣" en dus de lus:

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

zal echo slechts eenmaal oproepen en zal afdrukken

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

---

En ten slotte wordt "$@" uitgebreid naar "$1" "$2" , wat wordt uitgebreid naar "␣1␣2␣" "␣3␣␣4␣" en dus de lus

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

zal afdrukken

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

waardoor zowel de interne ruimte in de argumenten als de scheiding van argumenten behouden blijven. Merk op dat de constructie for var in "$@"; do ... is zo gebruikelijk en idiomatisch dat het de standaard is voor een for-lus en kan worden ingekort tot for var; do ...

$ HISTSIZE

Het maximale aantal onthouden commando's:

~> $ echo $HISTSIZE
1000

$ RANDOM

Telkens wanneer naar deze parameter wordt verwezen, wordt een willekeurig geheel getal tussen 0 en 32767 gegenereerd. Door een waarde toe te kennen aan deze variabele wordt de random number generator ( bron ) geplaatst.

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