Linux – Shell enzo… deel 8

Na 7 delen Linux, Shell Enzo heb je al een goed idee van alle mogelijke commando’s en parameters de Linux Shell ons te bieden heeft. Met deze duizenden commando’s tot onze beschikking kunnen we onze computer ten volste benutten. Systeemtaken, werkprocessen, automatische taken, spelletjes etc. De gehele computer is met de shell / terminal te besturen. Maar… hoe onthoudt je alle commando’s? Niet! Het is onmogelijk om alle commando’s en parameters te onthouden. De echte kracht zit hem in de mogelijkheid om de computer het werk te laten uitvoeren. En juist om deze reden schrijven we “Shell Scripts”.

Shell scripts zijn scripts met een verzameling Shell commando’s. Het script voert deze commando’s uit via de door u opgegeven volgorde. Shell scripts schrijven we in een teksteditor naar keuze waarin we ASCII tekst kunnen lezen en schrijven.

Voordat we aan het script beginnen eerst een aantal basisregels:

We starten een script met een zogenaamde “shebang” regel. In deze regel geef je de binary/applicatie op waarin het script gedraaid moet worden. In het geval van Bash is dat “#!/bin/Bash”
Alle overige tekst achter een hekje wordt gezien als “comment” en wordt dus niet actief uitgevoerd. Aangeraden wordt om in de header van het script een omschrijving te plaatsen
Maak je script leesbaar. Laat “child regels” dus netjes inspringen en gebruik waar nodig enters. Enters (witregels) worden door het script genegeerd.
Zorg dat je werkt met duidelijke error codes zodat je ook weet waarom een script faalt. Je kunt je script ook testen in b.v. http://www.shellcheck.net/
Tijdelijk bestand nodig, gebruik “/bin/mktemp”. B.v.: “tijdelijkbestand=$ (/bin/mktemp)
Gebruik “egrep” voor regex. B.v.: “egrep ‘localhost|127\.0\.0\.1’”
Als een commando faalt gebruik dan “set -e”

Laten we met bovenstaande in gedacht beginnen aan ons eerste script.

Een simpel script ziet er dan als volgt uit. Let op de “shebang”, en de comment:

#!/bin/bash
# My first script

echo "Hello World!"

Om het script uit te kunnen voeren moeten we het script eerst opslaan en uitvoerbaar maken middels chmod. Laten we het script opslaan als “mijnscript” en uitvoerbaar maken via:

chmod 755 mijnscript

Voor een privé script welke niet door een andere gebruiker uitgevoerd mag worden kun je “700” gebruiken als permissieset.

Als je de juiste permissies hebt om het script uit te voeren kun je deze uitvoeren door het plaatsen van een “./” voor het script. Dus:

./mijnscript

Dit werkt echter alleen als je in de juiste directory zit. Als je echter niet in de juiste directory zit dan zal het systeem je script niet vinden. Om dit te overkomen gaan we een directory “scripts” aanmaken en toevoegen aan het pad (PATH). Alle paden in het “pad” van Linux worden wel doorzocht als een commando wordt uitgevoerd. Als je “scripts” directory dus in het pad staat kun je op ieder moment je script uitvoeren (zonder toevoeging van “./”).

Alle huidige paden bekijken die in je pad staan:

echo $PATH

Een scripts directory aanmaken en toevoegen aan het “PATH”:

mkdir /home/user/scripts
 
export PATH=$PATH:/home/user/scripts

Het nadeel van bovenstaande methode is dat deze toevoeging slechts tijdelijk is. Wanneer de computer gereboot wordt zal het “pad” hersteld zijn naar zijn default waardes.

Nog beter is het dus om het pad toe te voegen aan je “.bash_profile”. Dit is een persoonlijk Bash profiel van de gebruiker welke iedere keer wordt uitgevoerd als een gebruiker inlogt. Om deze aan te maken en het pad toe te voegen doe je het volgende:

touch ~/.bash_profile
nano ~/.bash_profile
export PATH=$PATH:/home/user/scripts
source ~/.bash_profile

De eerste regel zorgt ervoor dat je Bash profiel script aangemaakt wordt (check dit eventueel met “ls -all”). Met de 2e en 3e regel openen we het bestand in de Nano editor en voegen we het pad toe. Met de laatste “source” regel zorg je ervoor dat aanpassingen in het profiel meteen van toepassing zijn (i.p.v. na een reboot).

Een andere (en laatste) permanente methode is de private “bin” folder. Deze folder wordt toegevoegd aan de home directory van de user. In deze directory worden alle uitvoerbare applicaties en bestanden van die gebruiker geplaatst. Deze directory zou automatisch herkend moeten worden door je Linux distributie (hoewel dit niet bij alle distributie het geval is). Als je deze directory nog niet hebt kun je deze simpel aanmaken middels:

mkdir ~/bin

Ok … we hebben ons eerste script gemaakt, uitgevoerd en de scripts bin toegevoegd aan het PATH.

Wat gaan we nu doen? We gaan een stapje verder en gaan verschillende methodes bekijken hoe we een script meer dynamisch en krachtig kunnen maken.

Quotes, Backslashes, Operators e.t.c.

Voordat we het script kunnen aanvullen moeten we eerst een aantal zaken ophelderen.

In scripts komen diverse “quoting” symbolen voor. Deze symbolen hebben als doel dat het script goed geïnterpreteerd wordt. Dus o.a. het samenvoegen van woorden en het bepalen van vervangingen.

Hierbij een aantal belangrijke symbolen uitgelegd.

” (dubbele quotes)
Dubbele quotes (ofwel “weak quoting”) worden gebruikt om woordgroepen te vormen. Wanneer woorden tussen dubbele quotes staan ziet Bash deze als 1. Bash zal niet elke woord separaat uitvoeren. Variabelen en Shell Expansions die gebruikt worden met dubbele quotes zullen nog gewoon werken. Binnen dubbele quotes hebben enkele quotes en wildcards geen functie en worden genegeerd.
’ (enkele quotes)
Enkele quotes (ofwel “strong quoting”) is eveneens om woordgroepen te vormen. Het grote verschil met de dubbele quotes is dat er binnen de enkele quotes helemaal niets gebeurt. Variabelen worden niet uitgevoerd en alles wordt gezien als “platte tekst”.
\ (backslash)
De backslash verteld de shell om “het volgende karakter” te negeren. Ze worden ook gebruikt om speciale karakters te gebruiken. Als het volgende commando een speciaal karakter is dan zal deze door de backslash genegeerd worden en als “normaal symbool” geïnterpreteerd worden. Zo kunnen we spaties gebruiken (zonder quotes) en kunnen we b.v. quotes meenemen als tekst i.p.v. als woordgroep. Hieronder zie je het idee:

Er bestaan ook speciale “backslash escape karakters” met een speciale functie zoals:

\n = Voegt een blanco lijn toe
\t = Voegt horizontale tabs toe
\a = Zorgt ervoor dat de terminal piept (alarm)
\\ = Backslash (de 2e slash wordt als normale slash gezien doordat de 1e backslash hem “escaped”

Dan zijn er ook nog speciale “operators” die we kunnen gebruiken om specifieke waardes te controleren. De volgende operators komen we geregeld tegen:

-e (controleer of het bestand bestaat)
-f (controleer of bestand een gewoon bestand is en geen directory of systeembestand)
-s (controleer of bestandsgrote hoger is dan 0)
-d (controleer of het een directory is)
-h (controleer of het een symbolic link is)
-r (controleer of de file “read” permissies heeft)
-w (controleer of de file “write” permissies heeft)
-x (controleer of de file “execute” permissies heeft)
-u (zet het user ID)
-eq (controleer of input (als integer) gelijk is aan…)
-ne (controleer of input (als integer) niet gelijk is aan…)
-gt (controleer of input (als integer) groter is dan…)
-lt (controleer of input (als integer) kleiner is dan…)
-le (controleer of input (als integer) kleiner OF gelijk is dan…)
= (controleer of input (als string) gelijk is aan…)
!= (controleer of input (als string) niet gelijk is aan…)
> (controleer of input (als string) groter is dan…)
< (controleer of input (als string) kleiner is dan…)
-z (controleer of input (als string) leeg is…)
-n (controleer of input (als string) NIET leeg is…)

Voor iedereen die het niet weet. Een “string” zijn 1 of meerdere karakters (meestal omsloten door quotes). De string kan uit allerlei karakters bestaan zoals letters, symbolen en cijfers. Een “integer” is een waarde die alleen uit hele cijfers bestaat zoals 1, 100, 1000 maar geen letters of gedeelde cijfers zoals 10,5.

Alias

Een alias kan gebruikt worden in scripting maar kan ook voor andere doeleinden gebruikt worden. Een alias is een “andere naam” voor een bepaald commando. Aliassen kunnen handig zijn om lange commando’s een stuk korter of beter begrijpelijk te maken. Een voorbeeld van zo’n alias is:

alias vandaag='date +"%A %-d %B %Y "'

Wanneer bovenstaande commando b.v. wordt toegevoegd aan je Bash profiel dan kun je het commando date +”%A %-d %B %Y” gemakkelijk uitvoeren door simpelweg “vandaag” in te typen.

In bovenstaande commando zie ook de enkele en dubbele quotes weer terug. De enkele quotes zorgen ervoor dat het in zijn totaliteit 1 commando is en niet 5 separate woorden (door de spaties). De dubbele quotes zorgen ervoor dat de variabelen wel als variabelen worden uitgevoerd.

Functies

Nu we weten wat aliassen zijn kunnen we net zo goed meteen doorgaan met shell functies. “Shell functions” zijn “scripts binnen scripts” ofwel sub-scripts. Je kunt een functie ook zien als een complexe alias. Met een functie vertaal je een compleet script naar een naam. Door het uitvoeren van die naam wordt de functie uitgevoerd. Zo kan een functie een combinatie zijn van meerdere commando’s.

Een functie wordt altijd aangeroepen met “function %functienaam%” of met “%functienaam% (). De verdere inhoud van die functie staat tussen brackets. Bijvoorbeeld:

function vandaag {
echo ‘De datum van vandaag is’
date +"%A %-d %B %Y "
}

We zien hier dat een functie aanmaken genaamd “vandaag”. Deze functie bestaat uit 2 commando’s, namelijk een echo commando en een datum commando.

Als we bovenstaande script uitvoeren gebeurt er echter helemaal niks. We maken hier de functie aan maar de functie wordt nog niet uitgevoerd. Om de functie aan te roepen gebruiken we de functienaam:

function vandaag {
echo ‘De datum van vandaag is’
date +"%A %-d %B %Y "
}
vandaag

Variabelen

Variabelen zijn “open plekken” in het script die ingevuld gaan worden door specifieke content. Deze variabelen zijn dus geen vast waardes maar zijn waardes die afhankelijk van voorgaande content die door het script gegenereerd is of van voor gedefinieerde content. Variabelen zijn eigenlijk delen in het geheugen waar men informatie in op kan slaan onder een vooraf gedefinieerde naam.

Variabelen worden gemaakt met een “=” teken en opgeroepen met het dollar teken ($). Bijvoorbeeld:

a=Jarno
b=Baselier
 
echo “Mijn voornaam is $a”
echo “Mijn achternaam is $b”

De uitkomst van dit commando is:

In bovenstaande voorbeeld hebben we de variabele vast ingevuld. Deze kunnen we echter ook dynamisch laten vullen met de content van b.v. een ander commando.

Dit doen we door het commando tussen haakjes ()te plaatsen en voorafgaand aan die haakjes een dollarteken te zetten, dus:

a=$(ls –l)
echo "De inhoud van mijn huidige directory is $a"

I.p.v. haakjes kun je voor bovenstaande ook het ` teken gebruiken en het voorgaande dollar teken negeren. Dus:

a=`ls -l`
echo "De inhoud van mijn huidige directory is $a"

Het is goed om te weten dat zodra de opgeroepen variabele tussen dubbele quotes staat de output van het commando netjes tabs en nieuwe lijnen weergeeft. Als de variabele niet tussen quotes staat van wordt alle output achter elkaar geplakt en wordt er dus geen rekening gehouden met tabs en nieuwe regels.

Variabelen moeten beginnen met een letter en mogen geen spaties bevatten. Ook kun je geen naam gebruiken voor een variabele welke al gebruikt wordt in Bash. Gebruik dus geen namen die overeenkomen met commando’s e.d.

Het Linux systeem bestaat ook al uit een aantal systeem variabelen welke gebruikt kunnen worden. Deze variabelen kunnen bekeken worden met het “printenv” commando. Zo bestaan de variabelen PATH en LOGNAME standaard in het systeem en kunnen dus ook altijd opgeroepen worden middels “echo $PATH”.

Positional Parameters

Net als systeem variabelen kent Bash een reeks aan “argumenten” ofwel “positional parameters”. Deze parameters geven weer welke informatie aan het script gegeven op het moment dat deze gestart werd.

We kennen hierin een aantal genummerde variabelen:

$0 = het gehele pad en naam van het script
$1 = De 1e input na het pad en het script
$2 = De 2e input na het pad en het script
$3 = De 3e input na het pad en het script
etc.

Stel je voor dat ons script de volgende code zou hebben:

echo "Positional Parameters"
echo '$0 = ' $0
echo '$1 = ' $1
echo '$2 = ' $2
echo '$3 = ' $3

En deze zouden we uitvoeren met:

# /home/user/Desktop/testscript

Dan zou het resultaat er als volgt uitzien:

$0 = /home/user/Desktop/testscript
$1 = 
$2 =
$3 =

Als we het script echter uit zouden voeren als:

# /home/user/Desktop/testscript extra input “voor gevaarlijke code”

Dan ziet het resultaat er als volgt uit:

$0 = /home/user/Desktop/testscript
$1 = extra
$2 = input
$3 = voor gevaarlijke code

Om het totaal aantal “positional parameters” te tellen gebruiken we de “$#” variabele.

Flow Controle

Bash scripts kennen ook flow controle commando’s. Dit zijn commando’s die bepalen welke delen van het script uitgevoerd worden. Zo kennen we de volgende belangrijke flow contol commando’s:

if / then
Het “if” commando is een voorwaardelijk commando. Hier vertellen we bash om een deel van het script te voldoen als er aan een bepaalde voorwaarde voldaan wordt. Dit commando ziet er als volgt uit: “if %voorwaarde” ; then”. Achter het “then” commando plaatsen we de commando’s die uitgevoerd worden als er aan de voorwaarde voldaan is. Als er niet aan de voorwaarde is voldaan dan gebeurt er verder niets en gaat het script door nadat het “if” statement is afgesloten. De “if” wordt afgesloten met een omgedraaide “if”, dus “fi”. Bijvoorbeeld:
if %voorwaarde% ; then commando fi
if %voorwaarde% ; then commando fi
else
Het else statement verteld wat er moet gebeuren als er niet aan de voorwaarde voldaan is. Dus als de voorwaarde matched doe dan A en anders B. Bijvoorbeeld:
if %voorwaarde% ; then commando else commando fi
if %voorwaarde% ; then commando else commando fi
elseif
De “elseif” wordt gebruikt om op een 2e conditie te controleren. Dus als de 1e conditie niet matched kijk dan of de 2e conditie matched. Zo niet voer dan niets uit en ga dan door naar de “fi”. Dus:
if %voorwaarde% ; then commando elseif %voorwaarde% ; then commando fi
if %voorwaarde% ; then commando elseif %voorwaarde% ; then commando fi

while / do
Het “while” commando is een “loop” commando. “While” test de input en voert vervolgens een blok code uit tot de waarde niet meer aan de test voldoet. Een simpel voorbeeld:

nummer=0
while [ $nummer -lt 5 ]; do
    echo "Nummer = $nummer"
    nummer=$((nummer + 1))
done

In dit script creëren we eerst een nummer variabele en geven deze als waarde “0”. Vervolgens zeggen we dat als het nummer lager dan 5 is de code uitgevoerd moet worden tot het “done” commando. Als het nummer hoger is dan wordt de code niet uitgevoerd en gaat het script verder na het “done” commando. Als de code wel uitgevoerd wordt dan tellen we 1 bij het nummer op. De while loop draait dus 5 keer.

Waar een “while” loop draait zolang de conditie “true” is kunnen we exact het omgekeerde doen. Hier draait de loop dus zolang de conditie “false” is. Dit doen we door “until” te gebruiken i.p.v. “while”. Deze loop kunnen we b.v. gebruiken om een menu te bouwen. Zie onderstaande voorbeeld:

selection=
until [ "$selection" = "0" ]; do
    echo ""
    echo "MENU"
    echo "1 - Laat vrije schijfruimte zien"
    echo "2 - Laat vrij geheugen zien"
    echo ""
    echo "0 - exit menu"
    echo ""
    echo -n "Maak uw keuze: "
    read selection
    echo ""
    case $selection in
        1 ) df ;;
        2 ) free ;;
        0 ) exit ;;
        * ) echo "Gebruik keuze 1, 2, of 0"
    esac
done

for
Het “for” commando geeft een variabele aan elk opgegeven waarde. We beginnen het “for” commando met het opgeven van de variabele gevolgd door “in” waarna we de waardes opgeven die deze variabele meekrijgen. Het “in” commando wordt weer gevolgd door het “do” commando waarna we opgeven wat er vervolgens moet gebeuren. Deze loop sluiten we af met het “done” commando. Om een simpel voorbeeld te laten zien kunnen we de 4 woorden in het onderstaande “in” statement toekennen aan de variabele (i) en laten echoën. Dus eerste word woord 1 toegekend aan de waarde waarna deze geëchood wordt. Vervolgens herhaald de loop dit voor woord 2 etc.
for i in word1 word2 word3; do echo $i done
for i in word1 word2 word3; do echo $i done
Het mooie aan de “for” loop is de manier waarop we het “in” statement kunnen invullen. In bovenstaande voorbeeld gebruikte we woorden. Maar het kan ook zo:
count=0 for i in $(cat ~/.bash_profile); do count=$((count + 1)) echo "Woord nummer $count = $i en bevat $(echo -n $i | wc -c) letters" done
count=0 for i in $(cat ~/.bash_profile); do count=$((count + 1)) echo "Woord nummer $count = $i en bevat $(echo -n $i | wc -c) letters" done
In bovenstaande commando zetten we de count variabele op 0. Vervolgens kijken we in het bash_profile (opgegeven in het “in” statement). Hier krijgt iedere woord de variabele “i” en voor iedere keer dat de loop draait telt de variabele “count” er 1 bij. Vervolgens wordt getoond het hoeveelste woord het is (count variabele) en welk woord het is (i variabele). Tenslotte wordt het woord (i variabele…indien deze niet blanco is (-n)) gepiped naar het “wc” ofwel “word count” commando met de -c toevoeging om de letters te tellen. De output is dus elke woord aanwezig in het bash profile, incl. hoeveel letters het woord lang is.

Arrays

Een array betekend in het Engels een rij of reeks. Een array is een lijst met een index. Een array heeft ook een naam zodat we deze op iedere plek kunnen aanroepen. Zo kunnen we bijvoorbeeld de kleuren “rood” en “blauw” als volgt tonen:

kleur1='Blauw'
kleur2='Rood'
echo $color1
echo $color2

We kunnen deze waardes ook in een array zetten waar “kleur1” toegewezen wordt aan index nummer 0 en “kleur2” aan index nummer 1:

kleur=('Blauw' 'Rood')
echo ${kleur[0]}
echo ${kleur[1]}

Zoals je kunt zien beginnen we een array met de naam van de array gevolgd door het = teken en dan de waardes van de array tussen de haakjes gescheiden met een spatie. Het is dus aan te raden om woorden tussen quotes te zetten zodat er ook woordgroepen aan een index toegewezen kunnen worden.

Er zijn verschillende soorten arrays zoals “pure”, “associatieve” en “dynamische” arrays. In feite is een array een variabele met meerdere waardes. De reden dat we arrays gebruiken is omdat de uiteindelijke code klein en goed leesbaar is. Daarnaast weet iedere developper wat een array is. Vanuit historisch oogpunt waren arrays ideaal omdat de geheugentoewijzing hiermee vastgelegd werdt en er dus zeer effectief naar een waarde in het geheugen gezocht kon worden. Dit is nog steeds belangrijk. Echter is dit met de moderne hardware en managed programmeertalen minder belangrijk dan vroeger.

Een ander voordeel aan een array is dat we direct waardes op een bepaalde positie op kunnen vragen. Om bijvoorbeeld de rode kleur op te vragen gebruiken we:

echo ${kleur[1]}

We kunnen ook de gehele array als volgt opvragen:

echo ${kleur[@]}

Of we kunnen het aantal items in de array tellen:

echo ${#kleur[@]}

Read

Er is nog 1 extra scriptoptie die ik nog snel even wil vertellen alvorens we gaan debuggen. Dit is de “read” functie. Met de read functie kan de gebruiker zelf tekst invoeren. Nadat de tekst is ingevoerd wordt de ingevoerde tekst opgeslagen in een variabele die later weer gebruikt kan worden.

Het volgende script:

read text
echo "U heeft de volgende tekst ingevoerd: $text"

Als men nu het script uitvoert kan men tekst invoeren. Als men het volgende invoert “bla bla bla” dan zal na het geven van een enter de volgende tekst verschijnen. Het read commando begint dus altijd met het commando zelf gevolgd door de variabele waarin de getypte tekst opgeslagen mag worden.

U heeft de volgende tekst ingevoerd: bla bla bla

Samen met het read commando kunnen we ook de -t (time) optie gebruiken om de gebruiker slechts een X aantal seconde de tijd te geven om te typen (en om ervoor te zorgen dat het script zonder input vast blijft hangen). Dit doen we als volgt:

echo -n "Snel… type iets en druk op ENTER! > "
if read -t 3 response; then
    echo "Heel goed… dat heb je snel gedaan"
else
    echo "Oeps… je bent te traag!"
fi

Debuggen

Ook debuggen is ontzettend belangrijk in een script. Om een script goed te debuggen bestaand er diverse methodes. Het uitvoeren van een commando en script genereerd altijd een error code. Zelfs als we deze niet gedefinieerd hebben. Door wel de juiste exit codes te definiëren en om de flow control op orde te hebben wordt debuggen een stuk gemakkelijker.

Laten we eerst een naar de “exit codes” kijken. Een script kan namelijk stoppen met 256 verschillende “exit codes” variërend van 0 tot 255 waar de 0 code staat voor succes en er dus 255 overige error codes zijn. Daarvan zijn de codes 1,2,126,127,128,130,255 ook gereserveerde systeemcodes. Dat betekend dat we als gebruiker nog 248 error codes over hebben om te gebruiken.

We kunnen de laatste exit code ophalen met de “$?” variabele. Dus:

echo $?

Dit werkt ook bij een script. Deze exit code is echter alleen van toepassing op het laatste commando. Als het laatste commando succesvol is maar alle voorgaande commando’s falen zal de exit code alsnog een 0 (succesvol) zijn. We kunnen exit codes gebruiken om debugging een stuk makkelijker te maken.

We kunnen de $? variabele ook in een script gebruiken. We roepen deze aan in een “if” flow na het uitvoeren van een commando om te achterhalen of het uitgevoerde commando succesvol was. Dus:

 
mkdir temp
 
if [ $? -eq 0 ]
then
  echo "De temp directory is aangemaakt"
else
  echo " De temp directory is NIET aangemaakt " >&2
fi

Bovenstaande voorbeeld zal een duidelijke foutmelding genereren maar als men na het draaien van het script de exit code bekijkt zal deze nog steeds 0 zijn. Het laatste commando (de echo) is namelijk wel succesvol uitgevoerd.

Om dit tegen te gaan kunnen we het exit commando gebruiken. Na het uitvoeren van het exit commando stopt het script met de opgegeven exit code. Bijvoorbeeld:

 
#exit 100 betekend dat de “temp” directory niet aangemaakt is
#exit 101 betekend dat de temp sub directory niet aangemaakt is.

mkdir temp
 
if [ $? -eq 0 ]
then
  echo "De temp directory is aangemaakt"
else
  echo " De temp directory is NIET aangemaakt " >&2
  exit 100
fi
 
mkdir temp/sub
 
if [ $? -eq 0 ]
then
  echo "De sub directory is aangemaakt"
else
  echo " De sub directory is NIET aangemaakt " >&2
  exit 101
fi
 
exit 0

Bash heeft ook een default debug functie. Dit is de “bash -x” functie. Op het moment dat je een script uitvoert met dit commando zal Bash het script in debug modes draaien en de output en eventuele problemen op het scherm tonen. Dus:

bash -x mijnscript

Om slechts een deel van het script te debuggen zet je een deel van het script in debug modes. Dit doe je door dat deel te ontsluiten met “set -x” en sluit je af met “set +x” . Zie:

set  -x
commando om te debuggen
set +x

Een ingewikkelder script

Met al deze kennis kunnen we al een groot aantal ingewikkelde scripts maken. Bekijk het volgende script maar eens:

#!/bin/bash
# Up script van Anuraag Sinha.
# Met het “Up script” maken we een functie aan die we kunnen gebruiken om een X 
# aantal directies omhoog te gaan in Bash. Noem dit script “up.sh”. 
# Plaats het script in een directory (b.v. “~/scripts/up.sh”) en zet de volgende code in je ~/.bash_profile: 
# “alias updir ='. ~/scripts/up.sh'” zodat het script altijd aangeroepen kan worden met het “up” commando.
# Om vervolgens 2 directies omhoog te gaan typ je “up 2”.

UPDIR_LVL=$1
 
if [ $# -lt 1 ]; then
 UPDIR_LVL=1
fi
 
UPDIR=""
for i in `seq 1 $UPDIR_LVL`;
do
 UPDIR="$UPDIR../"
done
 
cd $UPDIR

Allereerst maken we een variabele (UPDIR_LVL) aan en die stellen we in op de eerste positional parameter (dus het cijfer met het aantal stappen omhoog, laten we zeggen 3). Vervolgens maakt men een “if” statement die wordt uitgevoerd indien de input lager is dan 1. Dan zetten we de “UPDIR_LVL” variabele vast op 1. Dan volgt een nieuwe “if” loop waarbij we de huidige waarde van “UPDIR_LVL” gaan gebruiken. Deze loop wordt namelijk iedere keer uitgevoerd voor de waarde van “UPDIR_LVL”. Als deze dus 3 is wordt de loop 3x uitgevoerd. Iedere keer dat de loop uitgevoerd wordt schrijft deze de waarde “../” weg naar de variabele “UPDIR”. Na 3 keer is deze waarde dus “../../../”. Nadat de loop klaar is wordt het volgende commando uitgevoerd: “cd ../../../” waardoor de gebruiker dus 3 directories omhoog gaat.

Conclusie

Hopelijk heb ik jullie met bovenstaande uitleg een goede basis gegeven om te starten met je eerste shell script. Gebruik de kracht van scripts om het werk een stuk gemakkelijker te maken. Veel processen zijn te automatiseren en shell scripts zijn hier uitermate geschikt voor.

Als je deze informatie interessant en handig vond dan zou het awesome zijn als je dit bericht wilt delen / liken / uitprinten en boven je bed hangen … etc…

Op naar het laatste deel uit deze Linux – Shell Enzo reeks. Op naar deel 9.

Vond je het een interessant of leuk artikel? Overweeg s.v.p. of je me wilt sponsoren met een bakje arbeidsvitaminen. Want met koffie is immers alles beter :-)