Unix shell scripting

inleiding

Dit verhaal gaat ervan uit dat u enige ervaring met Unix hebt en dus met het typen van commando's in de shell. Het kan nooit kwaad om de uitgebreide informatie over een besproken commando op te vragen met man commando of (op GNU systemen) info commando.

Er zijn verschillende varianten op het Unix besturingssysteem; alle besturingssystemen die de hier besproken commando's bezitten worden hier voor het gemak met Unix aangeduid, ook al zijn ze niet gebaseerd op de originele code van A T & T. Op een Unix systeem zijn vaak verschillende shells te vinden. Het is ook mogelijk om een shell te draaien op Windows NT™. De voorbeelden bij dit verhaal zijn getest onder Linux en zullen op andere systemen soms aanpassing behoeven.

De oorspronkelijke /bin/sh is de Bourne shell, en de andere zijn daarvan afgeleid. De nummer twee was de C-shell, die handige features had om processen te besturen, maar minder handig om ermee te programmeren, en dus niet verder aan de orde zal komen. De nieuwere Korn shell lijkt weer meer op de Bourne shell, met de features van de C-shell, plus een hele reeks eigen uitbreidingen voor interaktief gebruik en programmeren. De Bourne Again Shell van het GNU projekt heeft eveneens een wijde verbreiding gekregen.

Mijn eerste scriptje

Het bijzondere aan de shell is dat hij zowel een handige commandoverwerker is voor interaktief gebruik als een programmeertaal. Verschillende delen van een Unix besturingssysteem bestaan uit shell scripts, omdat deze gemakkelijk door de gebruiker aan diens behoefte kunnen worden aangepast, wat vooral systeembeheerders waarderen. Shell scripts worden ook vaak gebruikt als een schil om een complexe applicatie.

Het is een kleine moeite om een korte reeks veel gebruikte commando's samen te voegen tot een scriptje: maak met vi (c.q. uw favoriete editor) een file voorbeeld aan met de volgende, vrij willekeurige, inhoud:

date
uname -a
who 								

In het voorbeeld is de directory waar het programma zich bevindt expliciet opgegeven. Als die wordt weggelaten zal de shell de lijst van directory's doorzoeken die in de speciale variabele $PATH staat. Het is enigszins riskant om de aktuele directory (.) in het zoekpad op te nemen.

Een standaard vergissing is om eigen programma's de naam test te geven. Helaas is test een ingebouwd commando van de shell. De shell heeft niet zoveel ingebouwde commando's: het meeste werk wordt door externe programma's gedaan.

hallo

Als volgende voorbeeld de nederlandstalige versie van het onvermijdelijke nutteloze programma hello, bekend van Kernighan & Ritchie.

#!/bin/sh 
# dit programma zegt vriendelijk goedendag 

echo Hallo, allemaal! ; exit 0					

#!/usr/bin/perl
print "Hallo, allemaal!\n"					

De opdracht echo is een ingebouwde functie van de shell, net als trouwens exit. Echo zorgt ervoor dat de resterende woorden op het standaard uitvoerkanaal (bijv. het scherm) worden afgedrukt. Shell commando's, argumenten en vlaggen moeten atlijd van elkaar worden gescheiden door spaties of andere scheidingstekens.

De opdracht exit beëindigt het script, ook als er nog opdrachten volgen; het gebruik ervan is niet verplicht. Net als de exit functie in een C programma wordt er een foutcode geretourneerd, die 0 bedraagt als er geen fout is opgetreden. Typ maar eens de volgende regels in achter de prompt.

true
echo $? 
false
echo $?								

Als u inlogt zal de shell eerst het script /etc/profile uitvoeren, waarin zich algemene instellingen bevinden, gevolgd door .profile in uw eigen directory, waarin u uw persoonlijke instellingen kwijt kunt. Bash en ksh kennen ook initialisatie files ~/.bashrc en ~/.kshrc die iedere keer uitgevoerd worden als een interactieve shell start, bijvoorbeeld bij het openen van een xterm.

een herhalingsoefening

De rest van dit hoofdstuk wordt besteed aan Unix en de shell, zonder dat er verder programmeren bij komt kijken. De behandeling zal erg oppervlakkig blijven; in paragraaf enkele Unix tools komen we er uitgebreid op terug.

Het centrale concept in Unix is de file oftewel het bestand. Files worden voortdurend gebruikt waar informatie voor min of meer lange tijd moet worden bewaard. Een file is een reeks bytes, die meestal op een schijf wordt bewaard. De belangrijkste operaties zijn het lezen of schrijven van een aantal bytes. Daarbij wordt de file pointer of bladwijzer om het aantal gelezen of geschreven bytes verplaatst. Verder is het mogelijk om de file pointer naar een opgegeven punt te verplaatsen en de lengte van het bestand in te krimpen tot bijvoorbeeld nul bytes.

De inhoud van een bestand ligt niet vast. Unix maakt vaak gebruik van tekstbestanden. Een byte staat dan voor een letterteken (karakter) van het ASCII alfabet. Het teken <LF> oftewel 0xa oftwel ^J oftewel \n geeft het einde van een regel aan. Er is geen teken nodig om het einde van een bestand te markeren, maar ^D kan worden gebruikt om invoer van de terminal te beëindigen.

Veel tools gaan ervan uit dat een bestand tekst bevat. Bijvoorbeeld zal cat voorbeeld de inhoud van het bestand over het scherm laten lopen. Als het bestand echter geen tekst bevat, dan kan de terminal de kluts kwijt raken van de stuurcodes; doe dus geen /bin/cat /bin/cat. Met cat -v loopt u geen gevaar.

In sommige Unices kunt u de schade repareren met het commando reset. De oude methode is de terminal uit en weer aan te zetten. De schade is te voorkomen. Het kommando file hallo zou iets moeten geven als hallo: Bourne shell script text.

Als file een frase met het woord `executable' erin retourneert, hebben we te maken met een binair programma. Een binair programma kun je alleen uitvoeren: dat werkt wel een stuk sneller dan een ingewikkeld shell script. File kan zich ondanks zijn `magic' uiteraard vergissen.

Verder zijn er speciale files, waarmee bijvoorbeeld apparaten kunnen worden afgelezen of beschreven alsof het files waren; een tape wordt bijvoorbeeld bediend als een hele lange pseudo-file, waarvan de grootte aan een vast maximum is gebonden. Deze worden vaak in de /dev directory gevonden.

Tekst die naar /dev/tty wordt geschreven, wordt wel zichtbaar gemaakt, maar niet opgeslagen. Een poging om /dev/tty uit te lezen retourneert niet de geschreven tekst, maar van het toetsenbord ingevoerde tekens. Unix zal u laten wachten totdat er een regel is ingevoerd, c.q. op de return-toets is gedrukt.

Om een tekstbestand uit te printen zou je cat hallo >/dev/lp0 of iets dergelijks kunnen doen, maar Unix staat dat enkel aan de user root toe. De juiste manier om een bestand te printen is via het printer spoolprogramma met lpr hallo

Een ander bestand dat in scripts gebruikt kan worden is /dev/null, ook wel de bittenbak genoemd, omdat alle data die er naartoe worden geschreven direkt worden weggegooid in tegenstelling tot de vuilnisbak van de Macintosh™. Lezen uit /dev/null is toegestaan, maar er zal niets uit komen.

De directory's kunnen worden beschouwd als een speciaal soort bestand, dat alleen met speciale opdrachten als ls, cp, mv, rm en ln kan worden gemanipuleerd. Directory's bevatten weinig anders als de namen van files en directory's. Daarom is voor een opdracht als rm -f ./voorbeeld schrijfpermissie op de aktuele directory vereist, maar geen permissie op het bestand. In scripts gebruiken we vaak de -f optie, zodat Unix niet nog eens vraagt of we het wel zeker weten.

Een file kan meerdere namen of links hebben; met het commando ln wordt een nieuwe link naar een bestaand bestand gelegd. ln /bin/ls /bin/dir maakt een nieuw commando, dir geheten, dat hetzelfde doet als ls. Met rm wordt het aantal links met één verminderd. Pas wanneer dat tot nul is gedaald en het bestand niet in gebruik is, zal Unix het bestand daadwerkelijk verwijderen.

Het is niet mogelijk naar een link te maken naar een directory of een bestand op een andere schijf. Deze beperking wordt opgeheven door de symbolic link of snelkoppeling, die je maakt met ln -s. Een snelkoppeling loopt het gevaar dat het bestand waar hij naar verwijst niet bestaat of dat een circulaire keten van links ontstaat. Vergelijk de uitvoer van ls -lL eens met ls -l.

-rwxr-xr-x 1 daniel users 769 Mai 29 example
-rwxr-xr-x 1 daniel users 769 Mai 29 voorbeeld

lrwxrwxrwx 2 daniel users   3 Jun 6 example -> wie
lrwxrwxrwx 2 daniel users   3 Jun 6 voorbeeld -> wie		

processen en hun in- en uitvoer

We zagen al dat een programma in Unix wordt opgeslagen in een bestand. Een Unix proces is een lopend programma, met zijn data en de context waarin het draait zoals de huidige directory. Moderne besturingssystemen kunnen een proces verdelen in zgn. threads; en programma kan daarmee meerdere taken tegelijk uitvoeren, die hun data delen, wat al snel in een chaos kan ontaarden.

De shell zal, met uitzondering van ingebouwde opdrachten, commando's uitvoeren door er aparte processen voor te starten. Shell scripts worden doorgaans in afzonderlijke processen (subshells) uitgevoerd. Ondanks dat Unix' multi-tasking efficiënter werkt dan huis-, tuin- en keuken besturingssystemen, maakt het voortdurende maken en opruimen van processen shell scripts een stuk langzamer dan andere programmeertalen.

Als een extern programma is opgestart zal de shell gewoon wachten totdat hij een seintje ontvangt van de kernel dat het kindproces is gestorven c.q. beëindigd.

Door een `ampersand' achter een commando te zetten als in voorbeeld&, zal het `in de achtergrond' worden verwerkt, en de shell onmiddellijk om de volgende opdracht vragen.

Een voorbeeld van een ingebouwde opdracht is het commando cd. Beginners verbazen zich er soms over dat een cd opdracht binnen een shell script wel wordt uitgevoerd, maar het effekt ervan vergeten is als het script beëindigd is en terug keert naar de interactieve shell.

Commando's in een script kunnen ook worden uitgevoerd met bijv. . ./voorbeeld. Hiermee worden de opdrachten in het bestand voorbeeld binnen de lopende shell uitgevoerd en werkt cd bijvoorbeeld wel. Een minder gebruikte mogelijkheid is om programma's (niet alleen scripts) te starten met de opdracht exec ervoor. Er wordt dan geen apart proces gemaakt, maar het nieuwe programma wordt in het lopende proces geladen en vervangt het, zodat het oorspronkelijke programma na afloop niet verder kan gaan.

Tot de context van een proces behoren ook de standaard invoer-, uitvoer- en error-kanalen. Voor een interactieve shell verwijst de standaard invoer naar het toetsenbord en de uitvoer en error kanalen naar het beeldscherm. Als u bent ingelogd via een modem of netwerk, dan verwijzen deze kanalen naar uw scherm en toetsenbord in plaats van dat van de computer waarop de shell draait.

Met ./voorbeeld <data >resultaat worden de kanalen omgeleid zodat de inhoud van het bestand data zal worden gelezen en de uitvoer in het bestand resultaat komt. Eventuele foutmeldingen komen nog op het scherm.

De notatie ./voorbeeld <data > >resultaat 2>&1 & zegt dat het script in de achtergrond moet draaien. We zien toch geen resultaten. Het dubbele `groter dan' teken geeft aan dat de uitvoer achter de bestaande inhoud van resultaat moet komen in plaats van het bestand eerst te wissen.

De aanduiding 2>&1 geeft aan dat het standaard error-kanaal (de tweede file-descriptor) een kopie is van nummer 1 (standaard uitvoer), dus foutmeldingen en resultaten verschijnen door elkaar heen in het bestand resultaat; het standaard-invoerkanaal heeft file-descriptor nummer 0. Kind processen erven file-descriptors (open bestanden); de standaard kanalen zijn altijd open. Als de standaard kanalen zijn omgeleid naar bestanden zijn toetsenbord en beeldscherm toch te benaderen door om te leiden naar het pseudo-bestand /dev/tty.

Een here-document is een bijzonder geval van omleiding waarin de te verwerken gegevens in het script-bestand zelf staan.

fox=dog; dog=fox
cat < <woord
The quick brown $fox jumps over the lazy $dog. 
…
woord 								

een les over `ls': jokertekens

Het volgende commando is een eenvoudige vervanging voor ls.

 
echo * | tr  " " "\n" | column					

Het illustreert hoe de shell jokertekens of wildcards behandelt. Als er in een woord een jokerteken voorkomt, dan zal de shell dat woord vervangen door alle bestandsnamen in de huidige directory die overeenkomen met dat zoekpatroon.

De * staat voor iedere reeks van nul of meer tekens, dus ls a*z geeft de lijst van alle bestanden waarvan de naam begint met een a en eindigt op z, zoals `alcatraz' (onder DOS/Windows kunt u de * alleen aan het eind gebruiken). Als er geen corresponderende bestanden zijn dan blijft de asterisk staan, bijv. echo Wie*dit*leest*is*gek

Het is mogelijk te voorkomen dat jokertekens worden vervangen door ze tussen aanhalingstekens te zetten of door er een backslash (\) voor te zetten; ls \* komt van pas, want een bestand met de naam * is niet uitgesloten.

Een . corrrespondeert met een willekeurig teken, zodat de shell p?n kan vervangen door pan pen pin pon. Een reeks van tekens tussen rechte haken kan worden vervangen door één van die tekens, bijv. ls fig-[123456789].jpg door ls fig-1.jpg fig-2.jpg

Let erop dat ls * ook de inhoud van subdirectory's weergeeft. ls geeft alleen files in de huidige directory en ls */ geeft de inhoud van alle subdirectory's.

pijpleidingen

Twee processen kunnen gemakkelijk via een pijp gekoppeld worden, zodat data die uit de standaard uitvoer van het eerste proces komen, door de standaard invoer van het tweede proces worden verwerkt, bijv.: ps -ef | sort

Het eerste commando geeft een lijst van alle processen die momenteel draaien en het sort commando sorteert ze (op de inlognaam van de gebruiker; werkt helaas niet op alle Unix versies gelijk). Als in een pijp een commando wordt gebruikt dat een filenaam als argument nodig heeft, dan kan meestal `-' worden gebruikt om de standaard invoer aan te duiden; veel commando's gebruiken automatisch de standaard invoer als ze geen bestandsnaam meekrijgen.

Een programma dat data van het standaard invoerkanaal leest en na een eenvoudige bewerking naar het standaard uitvoerkanaal schrijft noemen we een filter. Het eenvoudigste filter is cat, dat data onveranderd kopieert; sort is ingewikkelder.

Een ander filter is dd;. Voor details zie paragraaf split en dd; hier volgt een voorbeeld hoe je een bestand kunt converteren naar hoofdletters: dd conv=ucase <voorbeeld >gesorteerd 2>/dev/null

Dd wordt onder Unix wel gebruikt om een floppy disk te kopiëren met dd if=/dev/fd0 of=image-file Vervolgens verwissel je de disks en kopiëert de image file terug naar floppy.

Vergelijk het resultaat van find /bin | sort eens met ls -1 /bin/* en u ziet dat ls de gewoonte heeft de uitvoer te sorteren. Bij gebruik van een pijp wordt de uitvoer van het eerste proces opgeslagen in een kleine hoeveelheid buffergeheugen. Als dat vol is, wordt de producent stilgezet totdat de consument deze data heeft verwerkt.

Om de uitvoer van een commando op het scherm te bekijken en tegelijk een kopie in een bestand te bewaren gebruikt men iets als ./voorbeeld 2>&1 | tee resultaat

Als u beschikt over het tooltje netcat dan kunt u ook op eenvoudige wijze gegevens over een netwerk versturen. In plaats van prog1 | prog2 start u op machine host netcat -v -l -p 1234 | prog2 en op de andere machine doet u prog1 | netcat host 1234 Hierin is 1234 de gebruikte IP poort: een min of meer willekeurig nummer, mits de betreffende poort nog ongebruikt is, en prog1 en prog2 zijn willekeurige commando's. Netcat fungeert hierin als een pijp tussen processen op verschillende computers.

Alle Unix versies kennen de bovengenoemde anonieme pijp; sommige kennen ook een pijp die als een speciale file in het bestandssysteem voorkomt. Een pijp kan worden aangemaakt met mkfifo pijp of mknod pijp p Het mknod commando wordt ook gebruikt om speciale files van het block of character type aan te maken. Probeer maar eens welke output het file commando op een speciale file geeft.

variabelen

De werking van de shell is vrij ingewikkeld. Er zijn verschillende manieren waarop de shell reeksen tekens zal vervangen door andere. Een daarvan is de expansie van aliassen: het kommando l ~/*/a* kan worden uitgeschreven tot bijvoorbeeld /bin/ls -alg /home/gast/agf/aardappel /home/gast/agf/aardbei /home/gast/agf/appel /home/gast/autos/audi

De alias kwamen we zojuist tegen; aan 'ls' is hier het pad toegevoegd. De tilde staat voor de home directory, waarop de gebruiker `gast' inlogt; de uitdrukking `a*' wordt door de shell vervangen door een lijst van filenamen die met een a beginnen.

Een variabele is een naam, die door de shell aan een reeks tekens wordt gekoppeld met bijv. L='ls -alg '

Het kommando set zonder argumenten geeft een lijst van alle op dat moment gedefinieerde variabelen met hun waarden. De shell heeft zelf een aantal ingebouwde variabelen en andere variabelen worden bij het inloggen gedefinieerd, zoals $HOME, de home directory van de gebruiker en $PWD, de huidige directory.

We zijn ook al de variabele $PATH tegengekomen, ook wel het zoekpad genoemd. De waarde van $PATH is een lijst van directory's, gescheiden door dubbele punten. Als een commando dat geen slash (/) in de naam heeft, niet is ingebouwd in de shell of als alias is gedefinieerd, wordt gezocht of het commando overeenkomt met de naam van een file in een van deze directory's.

Hetzelfde kunt u doen met het which commando, dat echter niet op alle Unix systemen bestaat, of waarvoor soms een alternatief whence voor bestaat. Voorbeeld: which find

De shell zal een dollarteken gevolgd door de naam van een variabele vervangen door de waarde van de betreffende variabele. Nu kunnen we hetzelfde effekt als voorheen krijgen met $L.

Hadden we echter L de waarde `l' gegeven, dan zou het resultaat geweest zijn: l: command not found Bash en ksh brengen ons in dit geval verder met eval $L Hiermee wordt de uitdrukking `l' nog eens geëvalueerd, nadat de shell de waarde van L heeft gesubstitueerd. Een opdrachtregel als $apenkool zal niets doen en ook geen foutmelding opleveren als de betreffende variabele niet gedefinieerd is.

We krijgen de waarde van de variabele L terug met echo $L. Het dollarteken maakt eigenlijk geen deel uit van de naam. Als we nu een script of ander programma aanroepen waarin de waarde van variabele L gebruikt wordt, zal die echter ongedefinieerd zijn, tenzij we eerst de opdracht export L geven om een lokale variabele te exporteren naar de programma-omgeving. Echo en export zijn ingebouwde functies van de shell.

aanhaling

In de vorige paragraaf werd de waarde die aan L werd toegewezen omgeven door enkele aanhalingstekens. Deze zijn nodig om van de uitdrukking één woord te maken, inclusief de spaties. Dubbele aanhalingstekens hadden ook voldaan. Het verschil is, dat binnen dubbele aanhalingstekens de variabelen nog steeds worden vervangen door hun waarde, en alleen tekst tussen enkele aanhalingstekens letterlijk wordt overgenomen.

Tussen dubbele aanhalingstekens bestaat nog de mogelijkheid om aan te geven dat een enkel teken exact moet worden gekopiëerd; dit gebeurt door er een backslash voor te zetten als escape symbool.

De programmeertaal C definieert een aantal escape symbolen, die ook in de shell kunnen worden gebruikt.

Hierbij zij aangetekend dat de echo opdracht van de shell van zichzelf een <LF> (regeleinde) toevoegt, tenzij er echo -n is gebruikt; gebruikers van bash moeten echo de -e vlag meegeven om de escapes te laten werken. Het resultaat kan verschillen als er oktale codes boven 0200 worden gebruikt.

Een speciale functie van de shell is de commando substitutie, aangegeven door achterwaartse aanhalingstekens, bijv. L=`l` Hier wordt een aparte subshell gestart, waarin het commando ls -alg wordt uitgevoerd; het resultaat is weer te zien met echo "$L"

Probeer nu maar eens wat er gebeurt als de dubbele aanhalingstekens worden weggelaten. Een alternatieve notatie is om de te substitueren opdracht tussen $( en ) te zetten. Daarmee kunnen gesubstitueerde processen bovendien genesteld worden. Let op het verschil tussen de notaties $( lijst;van;commando's) en (lijst;van;commando's): beide voeren de opgegeven opdrachten uit in een aparte subshell, maar waar de uitvoer van de tweede variant gewoon tussen de standaard uitvoer verschijnt, wordt de uitvoer in het eerste geval een deel van de opdrachtregel.

Om een variabele af te scheiden van de rest van de tekst kan deze worden omgeven door dubbele aanhalingtekens of door accolades, zodat de volgende uitdrukkingen alle de waarde van de variabele L evalueren en er de letters `OVE' achter plakken.

echo "$L"OVE
echo ${L}OVE
echo "${L}OVE"							

parameters

We hebben inmiddels enkele manieren gezien waarop de shell ingevoerde tekens bewerkt, zoals de substitutie van variabelen en verwijderen van aanhalingstekens. Vervolgens wordt een commando in woorden opgeknipt, waarbij witruimte de scheiding tussen de woorden aangeeft. De variabele IFS bevat de tekens die hierbij als scheidingsteken worden gebruikt, standaard zijn dit <SP>, <TAB> en <LF>. Let erop dat een uitdrukking tussen enkele of dubbele aanhalingstekens altijd als een woord wordt gezien, ook al bevat ze spaties. Twee aanhalingstekens direkt achter elkaar tellen als een woord met lengte nul (0).

In een shell script zijn de parameters (c.q. argumenten en vlaggen) beschikbaar via de speciale variabelen $0 t/m $9 (en zonodig ook ${10} en hoger). $0 is de naam van het programma zelf. Daarmee is het mogelijk om bijvoorbeeld gunzip een link naar gzip te laten zijn en het programma verschillend te laten werken afhankelijk van de naam waarmee het is aangeroepen.

De shell kent nog een aantal speciale parameters; we zijn $? al tegengekomen, dat telkens de exit status van het laatste uitgevoerde commando krijgt. $$ bevat het Unix proces nummer van de shell die uw script draait. Dit kan ook handig zijn om unieke filenamen te maken voor tijdelijke bestanden.

De parameters $* en $@ leveren de complete parameterlijst op, met uitzondering van $0. Tussen dubbele aanhalings tekens gezet zal "$*" een woord opleveren dat overeenkomt met "$1 $2 $3…", terwijl "$@" een reeks woorden "$1" "$2" "$3"… geeft. De variabele $# geeft het aantal argumenten.

Hieronder volgt een scriptje om met het gebruik van parameters door de shell te experimenteren. De shift opdracht gooit de eerste parameter weg en schuift de rest een positie op, met uitzondering van $0. De regel met while wordt nader toegelicht in paragraaf herhalingen.

#!/bin/sh

echo "Script $0 aangeroepen met $# parameters:"

while [ $# -gt 0 ]
do 
  echo -n "\"$1\" "
  shift
done
echo
exit 								

Het verwerken van de parameterlijsten kan nog wat ingewikkelder worden. Zo kan met de notatie ${parameter:-woord} een standaardwaarde (default) worden aangegeven voor een weggelaten parameter of met {$parameter:?woord} een foutmelding worden gegeven als de parameter verplicht is, bijvoorbeeld

cp ${1:?"De eerste parameter is verplicht"} \
   ${2:-"."}							

als-dan

De meest elementaire programma-constructie laat één of meer opdrachten al of niet uitvoeren, afhankelijk van de uitkomst van een test, bijvoorbeeld:

if /usr/bin/test "A" = "a"
then
  echo "Gelijk"
else 
  echo "Verschillend"
fi						

Eerst wordt de opdracht achter if uitgevoerd. Er wordt dan gekeken welke exit status die opdracht oplevert. De meeste programma's geven standaard 0 terug, en 1 of een andere foutcode als er problemen zijn, /bin/true of : is altijd 0, en /bin/false altijd 1. echo 1 zal weliswaar 1 als output geven, maar het resultaat is 0.

De opdracht(en) achter then worden enkel uitgevoerd als de if-opdracht 0 oplevert, anders wordt het deel achter else uitgevoerd, maar het opnemen van een else-tak is niet verplicht. De if-constructie wordt pas uitgevoerd als het sleutelwoord fi is gelezen. In een interactieve shell krijg je een prompt string te zien om aan te geven dat de shell op de volgende opdracht wacht. Deze prompt wordt bepaald door de variabele PS1. Als een opdracht niet afgesloten is, krijgt u de prompt string PS2 te zien. De voorwaardelijke opdrachtregels worden hier ingesprongen om de leesbaarheid te verbeteren.

De Bourne shell is een vrij beperkt programma. Voor eenvoudige berekeningen kan het hulpprogramma expr worden gebruikt en test voor testen en vergelijken. Moderne shells als ksh, bash of tcsh hebben deze faciliteiten vaak ingebouwd. In plaats van de notatie test expressie gebruiken ze [ expressie ]. De shell wil spaties zien tussen de verschillende onderdelen van een expressie, terwijl in de opdracht variabele=waarde juist geen spaties voor of na het =-teken mogen komen. Voor uitgebreidere informatie zie paragraaf expr en paragraaf test.

Bovenstaand voorbeeld zal aangeven dat de strings "A" en "a" verschillend zijn. Hetzelfde geldt voor test "1" = "01" terwijl test "1" -eq "01" moet opleveren dat beide uitdrukkingen hetzelfde getal voorstellen. De opdracht test -e "$file" komt op hetzelfde neer als ls "$file" >/dev/null 2>&1. Zet variabelen tussen dubbele aanhalingstekens, anders zal het fout gaan als de variabele niet bestaat of leeg is.

Er bestaan nog twee beknopte voorwaardelijke opdrachten: commando1 && commando2 en commando1 || commando2 . In beide gevallen wordt eerst commando1 uitgevoerd. In het eerste geval wordt commando2 alleen uitgevoerd als het eerste exit status 0 (nul) oplevert, in het tweede geval als het resultaat van commando1 ongelijk is aan nul. Het resultaat is dus true als commando1 en c.q. of commando2 true opleveren.

meerkeuze tests

Om de waarde van een uitdrukking in de standaard uitvoer te krijgen wordt de echo opdracht gebruikt. Om een waarde van de standaard invoer te lezen en toe te kennen aan een of meer variabelen wordt read naam1 naam2… gebruikt. De variabelen krijgen dan elk een woord van de invoer als waarde. Als er geen variabelen worden opgegeven, wordt er een regel gelezen en in z'n geheel toegekend aan REPLY.

De if constructie kan met meerdere tests worden uitgebreid:

if test1 
then
  commando1 
else 
  if test2
  then 
     commando2
  else 
  …
  fi
fi						

  
if test1 
then
  commando1 
elif test2
then 
  commando2
else 
  …
fi						

Om de inhoud van een variabele met meerdere waarden te vergelijken gebruiken we de case constructie, zoals in het volgende voorbeeld.

echo -n $vraag		# variabele moet gedefinieerd zijn
read antwoord
antwoord=$(expr substr "$antwoord" 1 1 | tr \
  "[a-z]" "[A-Z]")
case $antwoord in
[YJDOS] )
  exit 0 ;;
N )
  exit 1 ;;
* )
  echo "Ongeldig antwoord!" 1>&2
  exit 2 ;;
esac						

Y (yes), J (ja), D (da), O (oui) of S (si) retourneren exit status 0 (true), N (nein of njet) retourneren 1 (false) en alle andere invoer komt overeen met de asterisk en resulteert in 2 met bijbehorende foutmelding op het standard error kanaal.

Een variant hierop is de select constructie, die niet in de originele Bourne shell voorkomt, waarmee eenvoudige menu's kunnen worden gemaakt.

echo -n $vraag 
select woord in ja nee
do 
  if /usr/bin/test "$woord" != "" 
  then 
    break
  fi
done							

herhalingen

In het voorbeeld hierboven wordt de invoer zo lang herhaald, totdat de gebruiker een geldige waarde heeft ingevoerd. Een meer algemene herhaling wordt geschreven als

while test
do 
  opdracht1 
  …
  opdrachtn
done						

De until constructie lijkt hier sterk op. Hierin wordt de lijst van opdrachten herhaald zolang als het resultaat ongelijk is aan 0. De uitvoering van het script gaat dan verder met de opdracht na `done'.

until test
do 
  opdracht1 
  …
  opdrachtn
done						

De for constructie wordt ook vaak gebruikt.

for variabele in lijst 
do 
  opdracht1 
  …
  opdrachtn
done						

for file in * 
do 
  if [ -f "$file" ] 
  then 
    wc "$file"
  fi
done							

Hier wordt voor elke file in de huidige directory het commando wc uitgevoerd, dat het aantal regels, woorden en tekens in het bestand telt. Gebruik van wc * is niet zo netjes omdat dan ook directory's en speciale files worden meegenomen.

for i in 1 2 3 4 5 6 7 8 9 10
do 
  for j in 1 2 3 4 5 6 7 8 9 10
  do 
    echo -n $( expr $i '*' $j) " "
  done
  echo
done						

Herhalingsopdrachten kunnen prima genest worden zoals in bovenstaand voorbeeld, dat de tafels van vermenigvuldiging afdrukt. Let op de enkele aanhalingstekens rond het sterretje. Er staat -n achter echo om de tafels op één regel te houden en er wordt een spatie tussenruimte ingevoegd.

Als het woord in en de volgende lijst afwezig zijn dan krijgt de variabele achtereenvolgens de parameters toegewezen waarmee het script werd aangeroepen, zodat we het programma van paragraaf parameters kunnen herschrijven als

echo "Programma $0 is aangeroepen met $# parameters"
for i
do
  echo $i
done						

Een while lus kan oneindig doorlopen als voor de test : of /bin/true wordt ingevuld. Een lus kan voortijdig worden verlaten met de break opdracht; met break 2 wordt in geval van twee geneste lussen de buitenste verlaten, enzovoorts. De opdracht continue zorgt ervoor dat de lijst opdrachten niet verder wordt afgewerkt en het script verder gaat met de test.

samenstellingen

Tot de samengestelde commando's behoren if, case, select, while, for, until en de functies, die verderop aan bod komen. Het simpelste samengestelde commando is

{
  opdracht1 
  …
  opdrachtn 
}								

Het groep commando zal de commando's in de groep na elkaar uitvoeren. De exit status van de laatste opdracht is tevens het resultaat van de groep. Zo kan bijvoorbeeld een pijplijn als een opdracht worden behandeld met { opdracht1 | opdracht2; }.

Als een lijst commando's in plaats van accolades tussen ronde haken () wordt gezet, worden die binnen een aparte subshell uitgevoerd. Dit geldt ook voor $( lijst ). In het laatste geval wordt de uitvoer van de lijst als deel van het script gebruikt.

functies

De definitie van een functie bestaat uit diens naam met een paar haken erachter, doorgaans gevolgd door een lijst commando's.

functie-naam()
{
  opdracht1 
  …
  opdrachtn 
}								

Een functieaanroep bestaat uit de naam van de functie gevolgd door de eventuele argumenten gescheiden door spaties. De betreffende commando's worden dan één voor één in de huidige shell uitgevoerd, waarna het script verder gaat waar het gebleven was. Binnen de functie zijn de argumenten beschikbaar als $1 …

De uitvoering van de functie stopt bij de afsluitende accolade of na een return opdracht, die bij voorkeur de laatste opdracht binnen de functie vormt. Achter return kan eventueel een exit status volgen, die aan het aanroepende script beschikbaar komt in $?. De exit status is altijd een geheel getal. Als een string als resultaat gewenst is, kan dat resultaat bijvoorbeeld met echo worden uitgevoerd en de functie via commando substitutie worden aangeroepen. In plaats van for i in 1 2 3 4 5 6 7 8 9 10 kan for i in `range 1 10` worden geschreven met de volgende functie:

range()
{ typeset i i

  i=$1
  while [ "$i" -le "$2" ]
  do
    echo $i
    i=`expr "$i" + 1`
  done
  unset i
}								

Het kan handig zijn om functiedefinities in een apart bestand functies te zetten en die met ./functies of source functies in te lezen. Bash zal een naam eerst proberen te koppelen aan een alias, dan een functie en als laatste een bestand met dezelfde naam gaan zoeken in zijn pad.

Binnen de functie zijn dezelfde variabelen als in de rest van het script te gebruiken en gewijzigde waarden blijven ook na afloop bestaan. In de Korn en Bash shell kunnen ook lokale variabelen worden gedeclareerd met de typeset opdracht, die alleen binnen de functiecontekst bestaat. In Bash kan hetzelfde ook met local worden bereikt. Een lokale variabele maskeert een eventuele globale variabele met dezelfde naam.

enkele voorbeelden

Het volgende voorbeeldprogramma geeft de namen van de ingelogde gebruikers. Na een tweetal functiedefinities volgt het hoofdprogramma, dat bestaat uit een pijp van vijf segmenten.

word()
{ if [ "$#" -gt 1 ]
  then
    i=0; n=$1; shift
    for j in $@
    do
      if [ $i = $n ]
      then
        echo "$j"
        break
      else
        i=$(expr $i + 1)
      fi
    done
  fi
} 

item()
{ OFS=$IFS; IFS=":"
  NR=$1; shift

  word $NR "$@" 
  IFS=$OFS
}

# het hoofdprogramma 
who \
| while read LINE1
  do 
    while read LINE2 
    do
      if [ "$(word 0 "$LINE1")" = 
           "$(item 0 "$LINE2")" ]
      then
        echo -e "$(item 0 "$LINE2")\011$(item 4
          "$LINE2")"
      fi
    done </etc/passwd
  done \
| sort \
| uniq -c							

De functie word retourneert het 1^e argument, dat wordt gebruikt om een regel in woorden te splitsen; handiger dan daar awk voor te gebruiken. De functie item maakt handig gebruik van de ingebouwde shell variabele IFS om de dubbele punt in plaats van de spatie als scheidingsteken te gebruiken. Het hoofdprogramma doet niets anders dan uit de uitvoer van who de username te knippen en die te vergelijken met het corresponderende veld uit /etc/passwd. De uitvoer wordt dan gesorteerd en dubbele regels verwijderd.

Deze functies worden ook weer gebruikt in het volgende script voor systemen die niet over een which commando beschikken (zie paragraaf variabelen). Dit script houdt echter geen rekening met aliassen en ingebouwde functies van de shell.

which_p()
{ f=0
  while :
  do
    f=`expr $f + 1`
    dir=`item "$f" "$PATH"`
    if [ "$dir" = "" ]
    then
      break
    fi
    path=$dir/$1
    if [ -f "$path" ]
    then
      echo "$path"
      break
   fi
done
}

# het hoofdprogramma `which'
if [ `expr match "$1" '.*/.*` -gt 0 ]
then
  if [ -f "$1" ]
  then
    echo "$1"
  fi
else
  echo `which_p "$1"`
fi								

Het volgende programma toont verschillen tussen twee bestanden, maar het is een stuk beperkter dan het diff commando. Hier wordt zoals uitgelegd in paragraaf processen en hun in- en uitvoer het standaard invoerkanaal omgeleid naar het bestand dat als eerste argument op de commandoregel is meegegeven en er het tweede bestand wordt gekoppeld aan het derde invoerkanaal.

doit()
{ LINE=0
  while read EEN<&0
  do
    LINE=`expr $LINE + 1`
    read TWEE<&3
    if [ "$EEN" != "$TWEE" ]
    then
      echo "$LINE""c""$LINE"
      echo "< $EEN"
      echo "---"
      echo "> $TWEE"
    fi
  done
}

# hoofdprogramma					
if [ "$#" -ne 2 ]
  then
  echo "Usage: $0 file1 file2"
  exit 1
fi
if [ -r "$1" -a -r "$2" ]
then
  doit 0<$1 3<$2
  exit 0
else
  echo "Invoerbestand(en) onleesbaar"
  exit 1
fi 								

een voorbeeld van een recursieve functie

Een functie mag ook zichzelf aanroepen (recursie), waarbij je moet voorkomen dat dat proces oneindig doorgaat. In onderstaand voorbeeld voor bash en ksh vindt de recursie alleen plaats als $1 > 0 en wordt het argument verlaagd om te zorgen dat na een aantal stappen $1 gelijk wordt aan 0.

Hanoi()
{ typeset i aantal

  if [ "$1" -gt "0" ]
  then
    aantal=$(expr $1 - 1)
    Hanoi "$aantal" "$2" "$4" "$3"
    echo "Verplaats een schijf van $2 naar $3"
    Hanoi "$aantal" "$4" "$3" "$2"
  fi
}
# Aanroepen met: 
Hanoi 4 "A" "B" "C"						

Voor wie het spel de Torens van Hanoi nog niet kent: je hebt een toren van 4 (of 64, maar dan duurt het spel erg lang) gouden schijven van verschillende diameter, die je één voor één van stapel A naar B moet verplaatsen, waarbij nooit een grotere schijf bovenop een kleinere mag komen te liggen. De optimale oplossing is om de bovenste drie schijven eerst recursief van A naar C te verplaatsen, waarna de onderste schijf van A naar B kan worden verplaatst en de rest weer recursief van C naar B.

Om te bewijzen dat een recursief algorithme korrekt is, is inductie nodig. Het is triviaal in te zien dat het algorithme een stapel van nul schijven van A naar B verplaatst door niets te doen. Voor n > 0 verplaats je eerst de bovenliggende (n - 1) schijven van A naar C en na het verschuiven van de n^e, weer van C naar B. Als we mogen aannemen dat het verplaatsen van (n - 1) schijven korrekt wordt uitgevoerd, dan gaat werkt het op deze manier ook voor een toren van n schijven.

De inductieregel stelt, dat aangezien het algorithme het gewenste effekt heeft voor n = 0 en dat voor elke n ⩾ 0 geldt, dat als het goed gaat voor n, ook een toren van (n + 1) schijven korrekt wordt verwerkt. Op dezelfde manier is te bewijzen dat als elke schijf groter is dan de schijf erboven, het algorithme nooit een grotere schijf bovenop een kleinere zal leggen: de toren van (n - 1) schijven is altijd kleiner dan de onderste en de onderste schijf komt nooit ergens bovenop te liggen.

Uit het algorithme volgt een recurrente betrekking voor het aantal verplaatsingen:

Door een tabel te maken van de waarden voor verschillende n zie je al snel dat dit overeenkomt met V(n) = 2ⁿ-1, wat vervolgens geverifiëerd kan worden.

Bewijzen dat er geen snellere weg bestaat, is moeilijker. Het kritieke pad is het verplaatsen van de onderste schijf van A naar B. Voor dat het zover is, moeten de schijven erboven eerst op één of andere manier naar C worden verplaatst en daarna weer naar B. Een van de weinige alternatieven is om eerst van A naar C te verplaatsen, en daarna van C naar B, maar dat maakt het enkel langer. Welke keuze je ook maakt, het heeft geen invloed op het verplaatsen van de resterende schijven.

signalen

We hebben al gezien hoe we processen in de achtergrond kunnen starten en kennis gemaakt met een manier om de manier om twee processen te coördineren door middel van een pijp: het eerste proces mag zolang in de pijp schrijven totdat de kleine buffer vol is; dan zal Unix het stoppen totdat er weer voldoende ruimte vrij is. Het lezende proces wordt telkens als de pijp leeg is in de wacht gezet.

De meeste vormen van interprocescommunicatie vergen een hogere programmeertaal. Voor de shell programmeur zijn de signalen het belangrijkst. Unix heeft twintig tot dertig voorgedefinieerde signalen plus twee vrij definieerbare. Met de opdracht kill signaal proces stuur je een signaal naar het opgegeven proces. De nummers van de processen zijn met ps te achterhalen. Het nummer van het proces zelf is te vinden in de variabele $$ en in bash zit het ouderproces in $PPID. De nummers van de signalen verschillen enigszins per Unix versie; de signalen kunnen ook met symbolische namen worden aangeduid; voor bash beginnen die met de letters SIG, maar in de korn shell moet dit voorvoegsel worden weggelaten.

Het effekt van een signaal is in de meeste gevallen dat het opgegeven programma onmiddellijk wordt beeindigd. Voor SIGKILL (9) is dit altijd het geval. Het ligt voor de hand dat alleen root het recht heeft om andermans processen te doden. Het besturingssysteem kan zelf besluiten een proces een signaal te geven. Als een programma stopt met segmentation violation, bus error, floating point exception of illegal instruction duidt dat meestal op een programmeerfout; shell scripts veroorzaken deze fouten zelden.

De gebruiker heeft een snellere manier om signalen naar het proces op de voorgrond te sturen. Deze kunnen vrij worden veranderd met het commando stty. Met stty -a krijg je een lijst van de ingestelde waarden, bijvoorbeeld Ctrl-D voor SIGHUP, Ctrl-C of Del voor SIGINT, Ctrl-\ SIGQUIT. Met Ctrl-Z wordt een lopend programma tijdelijk onderbroken. Onder bash kan een script zichzelf onderbreken met de suspend opdracht. De ingebouwde opdrachten met fg en bg zetten een onderbroken job voort in de voor- resp. achtergrond.

Met de opdracht sleep seconden wordt een programma tijdelijk onderbroken en zal het na het opgegeven aantal seconden met SIGALRM worden gewekt. De wait opdracht onderbreekt een proces zolang totdat het van Unix het signaal SIGCHLD krijgt dat het opgegeven kind proces of job in de achtergrond beëindigd is. Wait zonder argumenten wacht totdat alle kinderen afgestorven zijn. Als een proces in de voorgrond gestart is, wacht de ouder zonder expliciet wait commando.

Een proces kan ervoor kiezen bepaalde signalen gewoon te negeren, met uitzondering van SIGKILL en SIGSTOP. Het SIGHUP signaal dat aangeeft dat een terminalgebruiker de (telefoon)verbinding heeft opgehangen wordt genegeerd met nohup commando&. De standaard uitvoer en error kanalen worden dan omgeleid naar het bestand nohup.out.

Signalen worden asynchroon verwerkt, onafhankelijk van waar een proces mee bezig was en na afloop gaat het programma verder waar het gebleven was, tenzij het beëindigd is.

Met het commando trap commando signa(a)l(en) wordt aangegeven dat een bepaald commando moet worden uitgevoerd als het volgende signaal c.q. één van de signalen wordt ontvangen. Dit zal vaak de naam van de functie zijn die het betreffende signaal moet afhandelen. Als een script voortijdig moet worden afgebroken zal zo'n functie bijvoorbeeld tijdelijke bestanden verwijderen.

Trap heeft geen effekt op kind processen. Als het commando - luidt of ontbreekt, dan wordt de oorspronkelijke handelwijze hersteld. Als het commando een lege string is, dan zal de lijst van signalen door het script worden genegeerd.

expr

Wie een rekenmachine zoekt gebruikt meestal bc of xcalc. Expr is speciaal voor shell scripts. Elk argument is een getal of een operator, en moet door spaties gescheiden worden; speciale tekens moeten door backslashes worden voorafgegaan. Expr kent geen variabelen; daarvoor zijn shell variabelen. Om een getal met drie te vermenigvuldigen gebruiken we iets als i=`expr "3" \* "$i"`

De rekenkundige operatoren + voor optellen, - voor aftrekken, * voor vermenigvuldigen, / voor delen en % voor rest werken met gehele getallen. De vergelijkingsoperatoren >, <, >=, <=, = (in GNU expr ook ==) en != kunnen ook voor strings worden gebruikt. In tegenstelling tot de shell retourneren ze een 1 als de vergelijking waar is en anders 0, evenals de operatoren | (logische `of') en & (logische `en'). In plaats van een nul mag de lege string worden gebruikt en expressies kunnen tussen haakjes ( ) gezet worden. Let op dat in if $(expr "$i" = "") de aanhalingstekens om de variabelenaam niet gemist kunnen worden.

De Korn shell en bash hebben ook een ingebouwde rekenfunctie: de te berekenen uitdrukking wordt omgeven door $(( en )). Hier worden geen aanhalingstekens gebruikt en de spaties zijn niet vereist. Er zijn extra operatoren: = staat voor toewijzing, dus voor vergelijking wordt == gebruikt. Behalve in de decimale notatie kunnen getallen ook octaal worden genoteerd door ze met 0 te beginnen of hexadecimaal door er 0x voor te zetten. Het gebruik van de ingebouwde functie bespaart Unix de tijd voor het maken van het `expr' proces.

Expr kent ook een patroonherkenning operator : die een string vergelijkt met een reguliere expressie (zie paragraaf grep en reguliere expressies). Deze operator levert het aantal tekens dat overeenkomt op.

Modernere versies van expr bezitten een aantal string functies.

test

Het test commando, dat wordt gebruikt in voorwaardelijke opdrachten, zijn we al tegengekomen. Let op dat test een ingebouwde functie van moderne shells als bash of ksh is, die erg lijkt op /usr/bin/test. Die ingebouwde test functie kan ook worden genoteerd als [ expressie ]. De eerste toepassing is om te testen of een bestand bestaat.

Hedendaagse Unices hebben wat meer opties. De tweede groep tests vergelijkt strings.

Om in plaats van strings gehele getallen te vergelijken worden de operaties -eq, -ne, -gt, -ge, -lt, -le gebruikt. Getallen worden als strings weergegeven. Het verschil is dat test "02" -eq "2" 0 (true) zal opleveren en /usr/bin/test "02" = "2" 1 (false). Dit resultaat krijgt u te zien met echo $?. /usr/bin/expr "02" = "2" zal op de standaard uitvoer 1 (true) schrijven en de exit status 0 (true) retourneren.

De vierde groep zijn de verbindingen. ! expressie staat voor logische negatie, expressie1 -a expressie2 vormt een logische en en expressie1 -o expressie2 een logische of. Verder kunnen subexpressies tussen ( ) haakjes worden gezet.

grep en reguliere expressies

Grep is een tool om in tekstbestanden te zoeken; met binaire bestanden kunnen veel van de hier besproken tools problemen geven. U kunt het strings commando gebruiken om leesbare tekstfragmenten te vissen uit alle soorten files.

Sinds het ontstaan van Unix zijn er veel versies met verschillende kenmerken in omloop en bovendien zijn er egrep, fgrep en agrep bij gekomen. Ten behoeve van de portabiliteit zijn egrep of fgrep aan te bevelen.

Hieronder volgt de syntaxis van de fgrep opdracht. De rechte haken geven aan dat een onderdeel optioneel is en worden in een echte opdrachtregel niet opgeschreven, evenmin als cursieve termen letterlijk worden genomen.

fgrep [ optie ...] string ... [ file ...]

Fgrep is het beperktste en tevens snelste lid van de familie. Als er een enkele string als argument wordt meegegeven functioneert het als een filter dat van de regels in de invoer degene doorlaat die de opgegeven string bevatten.

Er kan op meerdere strings worden gezocht, die dan worden gescheiden door een regeleinde. De strings moeten dan tussen aanhalingstekens worden gezet om een argument te vormen en alle regels die één van de strings bevatten worden afgedrukt. Fgrep kent de volgende opties.

Er bestaan meer opties, maar die verschillen per systeem. Als je wilt testen of een bepaalde string in een bepaalde file voorkomt kun je de -s (silent) optie gebruiken (BSD), of -q (quiet, GNU) om de standaard uitvoer te onderdrukken.

Het volgende voorbeeld geeft een lijst van al je processen. (de juiste opties van ps hangen af of je OS tot de System V of BSD familie behoort)

ps -al | fgrep `fgrep $USER /etc/passwd | cut -f 3 -d ':'` 	

De binnenste fgrep selekteert de regel van de ingelogde gebruiker uit het wachtwoordbestand. Cut knipt daaruit het derde veld, waarbij de dubbele punt als scheidingsteken wordt gebruikt. De buitenste fgrep selecteert de regels met dit User ID uit de uitvoer van ps. Vergelijk met het voorbeeld uit paragraaf enkele voorbeelden.

De functionaliteit van grep zelf verschilt nogal per systeem, en daarom wordt hier het uitgebreidere egrep besproken. De opties zijn hetzelfde, maar het zoekt naar reguliere expressies in plaats van alleen letterlijke strings. Reguliere expressies lijken op de wildcards (jokertekens, zie paragraaf een les over `ls': jokertekens) * en ? die de shell gebruikt om naar bestandsnamen te zoeken, maar de notatie verschilt sterk. Denk eraan de zoekstring tussen enkele aanhalingstekens te zetten om verhaspelen door de shell te voorkomen. Het kan geen kwaad om zelf eens wat te proberen op een grote woordenlijst.

egrep -i 'abc
def' /usr/share/dict/words					

Reguliere expressies moeten voldoen aan de volgende regels.

• Een enkel teken dat geen speciale functie heeft, komt overeen met dat teken zelf

• Om te zoeken naar een teken dat een speciale functie heeft, moet je er een \ voorzetten, bijv. egrep '\\'

• Een reeks tekens tussen vierkante haken wordt gebruikt om te zoeken naar een enkel teken uit deze reeks, zo correspondeert [0123456789] met een enkel cijfer.

• Tussen vierkante haken kan een reeks tekens worden aangegeven met een koppelteken tussen het eerste en laatste teken, bijv. [0-9].

• Een punt correspondeert met een willekeurig teken, bijv. .a.b.c..de met `barbecuede'.

• De reguliere expressie exp1exp2 correspondeert met string1string2 als exp1 correspondeert met string1 en exp2 correspondeert met string2, waarbij string1 de langst mogelijke string is waarvoor nog een correspondentie met exp2 mogelijk is.

• De reguliere expressie (exp) correspondeert met alle strings die corresponderen met exp.

• De reguliere expressie exp1|exp2 correspondeert met alle strings die corresponderen met exp1 of exp2. Iets handiger dan een regeleinde.

• De reguliere expressie exp1* correspondeert met alle strings die nul of meer keer corresponderen met exp1. Zo komt a.*b.*c.*d.*e overeen met o.a. `Abcoude' en blijkt bijv. egrep `(bla)*(bla)' dezelfde output op te leveren als fgrep bla.

• De reguliere expressie exp1+ is equivalent met exp1(exp1)*.

• De reguliere expressie exp1? is equivalent met exp1|().

• De reguliere expressie exp1\{aantal1\} is equivalent met exp1 aantal1 keer achter elkaar.

• De reguliere expressie exp1\{aantal1,\} is equivalent met exp1 aantal1 of meer keer achter elkaar.

• De reguliere expressie exp1\{aantal1,aantal2\} is equivalent met exp1 minstens aantal1 en hoogstens aantal2 keer achter elkaar.

• De reguliere expressie ^exp1 correspondeert met alle regels waarin exp1 aan het begin van de regel voorkomt.

• De reguliere expressie exp1$ correspondeert met alle regels waarin exp1 aan het eind van de regel voorkomt.

Een uitbreiding op de Reguliere Expressies, die oudere Unices missen, zijn de karakter klassen die een uitbreiding vormen van de lijsten karakters.

Welke tekens tot deze klassen behoren is afhankelijk van uw locale. Als Unix uw moedertaal is, dan typt u export LANG=C of export LANG=POSIX. De klasse [:upper:] bevat dan alleen de ASCII tekens A - Z, maar met export LANG=nl_NL worden ook de diakritische tekens als ÄÛÉÒÑÅßÇijŘŌŒİı met ASCII nummers boven 127 toe gerekend. Ook de volgorde van de output van sort -d -f is afhankelijk met de ingestelde locale.

De equivalentie klassen zijn eveneens afhankelijk van de locale en worden door GNU nog niet goed ondersteund. De notatie [[=letter=]] duidt de verzameling van tekens aan die in het woordenboek op de zelfde plaats komen, zoals hoofdletters en letters met een accent.

De GNU versie heeft weer een uitgebreidere set van regels, waaronder de mogelijkheid om terug te refereren naar een eerdere RE tussen haakjes met een backslash gevolgd door het nummer van die expressie, bijv. ([a-z]) is een \1.*" correspondeert met regels als `a is een aapje, dat eet uit zijn poot', `b is een bakker, die bakt voor ons brood'.

Nog uitgebreider dan egrep is agrep, een algorithme van Sun Wu en Udi Manber. Hiermee kun je zoeken op strings die ongeveer gelijk zijn aan het zoekpatroon.

De belangrijkste extra optie is het maximum toegestane aantal fouten (letters die je moet wijzigen, toevoegen, vervangen om ze met het zoekpatroon te laten overeenkomen). Als eerste optie wordt dan -1, -2, ... aangegeven.

Een andere extra optie is mogelijkheid te zoeken naar alle strings die een uitbreiding van het zoekpatroon bevatten. In plaats van egrep 'a.*b.*c.*d.*e' schrijf je dan agrep -p 'abcde'.

find en xargs

Een van de meest voorkomende taken van shell scripts is het zoeken naar bepaalde bestanden en het bewerken ervan. Script programmeurs gebruiken hiervoor liever find dan ls. Find zoekt een directory en diens subdirectory's recursief af en levert als uitvoer een reeks padnamen (namen van bestanden plus directory's) die aan bepaalde criteria voldoen. De uitvoer wordt niet gesorteerd.

Om een commando uit te voeren op elk van de gevonden bestanden zou je iets kunnen doen als

for bestand in `find ....`
do 
  commando $bestand 
done 								

De oplossing is de xargs opdracht, die het commando naar wens herhaalt, bijvoorbeeld tien keer met telkens honderd argumenten, als er duizend bestanden zijn gevonden. De syntaxis van deze opdrachten luidt:

find [ file ...] [ expressie ] | \
xargs [ optie ...] [ commando ] [ argument ...]

Het volgende voorbeeld zoekt alle core dumps in uw home directory en subdirectory's. find ~ -name "core" -print | xargs file

De lijst van argumenten begint met een reeks directory's die worden doorzocht, gevolgd door een optionele reeks van tests en een of meer akties. De akties worden alleen uitgevoerd als alle opties true opleveren; er mag ook -a tussen worden gezet. Als meerdere opties worden verbonden door -o dan zal de combinatie waar (0) opleveren als één ervan waar is. Het resultaat van een optie kan worden omgekeerd door er een ! voor te zetten en opties mogen tussen ( ) haakjes worden gegroepeerd. De haakjes moeten door een backslash worden beschermd tegen substitutie door de shell.

Find kent de volgende tests:

In de voorafgaande opties kan gehalve n om een aantal aan te duiden ook de notatie +n worden gebruikt voor aantallen groter dan n of -n om aantallen kleiner dan n aan te duiden.

Het volgende voorbeeld zoekt naar andermans files in uw home directory. find ~ \! -user $USER -type f -print | xargs ls -l

Find kent de volgende akties:

Hieronder een iets andere manier om core files te zoeken. Let op de backslashes. find ~ -name core -exec file \{\}\; -print | grep core Een handige manier om de inhoud van directory origineel met alle subdirectory's te kopiëren naar directory bestemming gebruikt de pass-through optie van cpio: find origineel -print | cpio -pdm bestemming. SCO Unix heeft hiervoor een copy commando.

directory's doorlopen met du

De du utility geeft een overzicht van de hoeveelheid schijfruimte die een bepaalde directory samen met de onderliggende subdirectory's in beslag neemt. Behalve als een uitgebreide versie van df kun je het ook beschouwen als een snelle variant op find, die alleen directory's weergeeft. De syntaxis luidt:

du [-a ] [-k ] [-s ] [-x ] [ directory ...]

Als er geen directory's opgegeven zijn, bekijkt du de huidige directory. De opties zijn als volgt:

sed, editen vanuit een script

Met behulp van egrep kun je informatie zoeken in een tekstbestand. Om regels te wijzigen is er de stream editor sed, een broertje van de ed editor, die weer een voorloper van vi is, die speciaal gemaakt is voor gebruik in scripts. Sed kopiëert telkens een volgende regel van de invoer naar de patroonbuffer, voert de opdrachten in zijn edit script één voor één uit en kopiëert de buffer naar de uitvoer. De syntaxis luidt:

sed [-n ] [-e script ] [-f sfile ] [ file ...]

Als de filenaam of -namen ontbreken dan zal sed de standaard invoer verwerken. Het edit script kan op de commandoregel achter de -e vlag tussen aanhalingstekens worden meegegeven of worden gelezen uit de file die met de -f vlag wordt aangeduid. Als de -n vlag wordt gebruikt, dan wordt er alleen uitvoer gegeneerd door de print opdracht.

Onderstaand scriptje print de regels uit het wachtwoordbestand die de letters rot of root bevatten, net als egrep. Zonder de -n vlag zouden deze dubbel worden geprint. sed -n -e '/ro\+t/p' /etc/passwd

Sed scripts zien er nog cryptischer uit dan shell scripts; ze bestaan in het algemeen uit regels van de vorm

[ adres1 [, adres2 ] ] [! ] [ argument ...]

Een scriptregel zonder adres wordt toegepast op elke regel in de invoer, met één adres wordt de functie toegepast op elke regel die met adres1 overeenkomt, en met twee adressen op de regels vanaf de eerste die overeenkomt met adres1 tot de volgende die overeenkomt met adres2. Als dat niet geworden wordt, tot aan het eind van de file. Als achter het adres een uitroepteken staat wordt de functie toegepast op alle regels die niet geselecteerd zijn.

Een adres kan een decimaal regelnummer zijn, cat vanaf 1 geteld wordt, $ voor de laatste regel of een reguliere expressie tussen schuine strepen. De GNU versie staat toe de reguliere expressie te begrenzen met een ander teken dan de slash. Het volgende voorbeeld retourneert de regels tussen 'root' en `bin' uit hter wachtwoordbestand. sed -e '\#root#,\#bin#!d' /etc/passwd

Sed kent onder andere de volgende functies:

Het volgende voorbeeld zet regelnummers voor de invoer; BSD en gnu systemen bereiken hetzelfde met cat -n. Omdat de regelnummers op aparte regels komen, wordt een tweede sed commando gebruikt om ze samen te voegen en de regeleinden te vervangen door spaties.

sed -n -e '=; p' | sed -n -e 'N; s/\n/ /p' 			

De volgende variant illustreert hoe met tweetal adressen meerdere regelbereiken worden gevonden.

ls /bin | sed -n -e '/name/,/t/{=;p;}' | \
  sed -n -e 'N; s/\n/ /p'					

Het volgende voorbeeld zet een spatie achter ieder teken en een lege regel achter iedere regel en vervangt alle kleine letters door hoofdletters.

sed -e 's/\(.\)/\1 /g 
y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/
G'								

Voor meer informatie en voorbeelden, zie the seders' grab-bag. Hierna volgt een wat uitgebreider shell script dat gebruik maakt van sed om commentaar in C⁺⁺ stijl te veranderen in standaard C code. Het maakt gebruik van ledige substituties om te testen of een bepaald patroon in de invoerregel voorkomt. De functie extension behoeft wellicht verbetering voor namen als app-1.0.0.tar.gz.

subst()
{ sed -e '
         //\*/s/$//
         t loop
         b cont

:loop
         /\*//s/$//
         t cont
         n
         b loop
:cont
         /\/\//s/$//
         t found
         b
:found
         /\".*\/\/.*\"/s/$//
         t
         /\*\/\/\*/s/$//
         t
         /\/\*.*\/\/.*\*\//s/$//
         t
         /\/\//s/$/ \*\//
         /\/\/.*\/\*.*\*\//s/\*\///
         /\/\//s//\/\*/
         t
         ' $1
}

stringlen()
{ if [ "$1" = "" ]
  then
    echo "0"
  else
    expr length "$1"
  fi
}

substring()
{ if [ "$1" = "" ]
  then
    echo ""
  else
    expr substr "$1" "$2" "$3"
  fi
}

lastindex()
{ name="$1"
  DotPos1=0
  DotPos2=`expr index "$name" "$2"`
  while [ "$DotPos2" -gt "0" ]
  do
    DotPos1=`expr $DotPos1 + $DotPos2`
    DotPos2=`expr $DotPos2 + 1`
    name=`substring "$name" $DotPos2 999`
    DotPos2=`expr index "$name" "$2"`
  done
  echo $DotPos1
}

extension()
{ DotPos=`lastindex "$1" "."`
  if [ "$DotPos" -gt "0" ]
  then
   substring "$1" `expr $DotPos + 1` `stringlen "$1"`
  else
    echo ""
  fi
}

# main loop - find files to be modified 
find . -print \
| while read i
  do
    if [ -f "$i" ] && [ -r "$i" ]
    then
      if [ -w "$i" ]
      then
        if [ "`extension $i`" = "c" ] || \
           [ "`extension $i`" = "h" ]
        then
          if grep '//' $i > >/dev/null
          then
            echo "File $i is modified."
            mv "$i" "$i"~
            subst "$i"~ >$i
          fi
        fi
      else
        echo "File $i is not writable!"
      fi
    fi
  done								

tabellen verwerken met awk

De scripttaal awk (klinkt als `look awk`) is genoemd naar haar makers, Aho, Weinberger en Kernighan van A, T & T. Awk is uitgebreider dan sed en vooral geschikt voor het verwerken van tabellen. Veel Unix commando's als ls, ps, en who produceren tabellen, platte tekstfiles bestaaande uit kolommen met een vaste breedte. De syntaxis luidt:

awk [ optie ...] [ -f sfile ] 'script' [ file ...]

De belangrijkste optie is -Ft, waarmee het teken t als field separator wordt ingesteld. Het script zelf kan weer als een groot argument op de commandoregel worden meegegeven of in een aparte file met -f, en als er geen verdere filenamen zijn meegegeven, dan zal awk de standaard invoer verwerken. Awk scripts hebben over het algemeen de vorm

[BEGIN {actie}] [patroon] [{actie}] … [END {actie}]

Net als bij sed zal elke invoerregel één voor één met de patronen worden vergeleken en voor elk patroon dat overeenkomt zal de bijbehorende actie worden uitgevoerd. Als er geen patroon is opgegeven wordt de actie altijd uitgevoerd en als er geen actie staat, dan wordt de invoerregel afgedrukt. De eventuele actie achter begin wordt voor het inlezen van de eerste regel uitgevoerd en de actie achter end na het eind van de laatste regel. Het eerste voorbeeld verwijdert lege regels uit de invoer: awk '$0'

Hierin staat $0 voor de invoerregel. De invoerregel wordt door awk gesplitst in velden, gescheiden door witruimte of een ander scheidingsteken, genaamd $1, $2, …. NF is het aantal velden en NR het aantal records c.q regelnummer. Het toevoegen van regelnummers aan de input gaat met awk eenvoudiger dan met sed: awk '{print NR " " $0}'

De patronen kunnen boolese combinaties van reguliere expressies en / of relationele expressies zijn. De boolese combinatoren zijn ! (niet), && (en), || (of) en de ( ) haakjes; de reguliere expressies zijn eerder besproken; de relationele combinatoren zijn < (kleiner), > (groter), <= (kleiner of gelijk), >= (groter of gelijk), == (gelijk), != (ongelijk), ~ (komt overeen met reguliere expressie) en !~ (komt niet overeen met RE).

Expressies kunnen verder bestaan uit variabelen, numerieke constanten (gehele getallen of drijvende komma) en string constanten (tussen dubbele aanhalingstekens) en de rekenkundige operatoren + (optellen), - (aftrekken), * (vermenigvuldigen), / (delen), % (rest), ^ of ** (machtsverheffen), ++ (1 optellen) en -- (1 aftrekken) als in de programmeertaal C en de string operator ' ' (samenvoeging).

Behalve enkelvoudige patronen kunnen net als bij sed reeksen regels worden opgegeven met een tweetal patronen. De volgende regel selecteert de regels 10 t / m 20 van een bestand. awk 'FNR==10, FNR==20' /etc/hosts

Een awk script kan ook variabelen aanmaken; declareren is niet nodig. Een variabele kan zowel als string als getal worden gebruikt en wordt automatisch geïnitialiseerd met waarden 0 en "". De operatoren bepalen het type van het resultaat: zo levert ("3x" + 1) 4 op maar ("x3" + 1) 1. Behalve een constante tussen schuine strepen kan ook een variabele als reguliere expressie worden gebruikt. De eenvoudigste acties zijn variabele = expressie en print expressie. Het is ook mogelijk om de veldvariabelen $1, $2,… een andere waarde toe te kennen.

Moderne awk varianten kennen associatieve arrays. Arrays hoeven niet gedeclareerd te worden: het is voldoende een element van een array een waarde te geven met naam[ index] = waarde. Voor de index kunnen gehele getallen of willekeurige strings worden gebruikt, zelfs meerdere getallen zijn toegestaan om pseudo-multidimensionale arrays te maken. De waarden van de index hoeven niet opeenvolgend te zijn.

Awk kent een aantal rekenkundige functies.

Awk kent verschillende string functies.

Awk lijkt een beetje op C. Acties c.q. statements worden gegroepeerd door accolades en afgesloten door een puntkomma of nieuwe regel. Een lang statement kan worden voortgezet door de regel met een backslash te beëindigen. Na een # hekje wordt de rest van de regel als commentaar beschouwd. Het if-statement heeft de volgende syntaxis.

if( expressie ) statement1 [else statement2]

Als de expressie ongelijk is aan 0 c.q. "", dan wordt het eerste statement uitgevoerd en anders het optionele tweede. Voor herhaling bestaan er twee varianten van while en de for-lus.

while( expressie) statement do statement while (expressie) for( expressie1; expressie2; expressie3) statement

De eerste expressie achter for initialiseert de lus, de tweede test of de lus beëindigd moet worden en de derde wordt na elke doorgang uitgevoerd. Om tot tien te tellen gebruik je awk 'BEGIN {} {} END {for( i = 1;i <= 10;i++) print i}'

De volgende vorm van de for-lus loopt alle elementen van een array af:

for (variabele in array) statement

Met break kan een lus voortijdig worden verlaten; met continue wordt de rest van de inhoud van de lus overgeslagen en met exit wordt de rest van de invoer overgeslagen en gaat awk verder met de eventuele actie achter end; in de end-sectie kan weer een exit opdracht volgen met een exit status.

In moderne versies van awk kunnen in een script eigen functies gedefinieerd worden met

function naam( parameter1, … ) { statements }

Functies moeten worden gedeclareerd voordat ze kunnen worden gebruikt. Met de return opdracht kunnen ze een waarde teruggeven. Als in een functie de waarde van een parameter gewijzigd wordt, dan zal dit geen effekt hebben op de waarde van een variabele die als argument is meegeven, behalve voor arrays.

Het is mogelijk om met print naar een willekeurige file te schrijven met de notatie

print waarde >"file"

Zonder de aanhalingstekens is file een variabele die de naam van het bestand bevat. Om de uitvoer achter de bestaande inhoud van het bestand te plakken wordt het volgende gebruikt:

print waarde > >"file"

Het is ook mogelijk om binnen een awk script een extern commando te starten dat de uitvoer van print leest met de notatie

print waarde | "commando"

Om de output van een extern commando in te lezen kun je iets als system( "commando" | getline) gebruiken.

Om nette tabellen te maken wordt het printf statement gebruikt met de volgende syntaxis:

printf "formaat", expressie1, …

De formaat string wordt gewoon afgedrukt, afgezien van formaat specificaties, die worden vervangen door één van de volgende expressies. Anders dan voor print moet de formaat string worden afgesloten met een regeleinde (\n). Een formaat specificatie geeft aan in welk formaat de bijbehorende expressie moet worden afgedrukt en heeft de vorm

%[-][0][breedte[.precisie]]type

De expressie wordt afgedrukt in breedte kolommen, mits het daarin past, en eventueel aangevuld met spaties, maar als de breedte met 0 begint, worden er voorloopnullen gebruikt. Een eventueel min-teken geeft aan dat de waarde links moet worden aangelijnd. Voor getallen geeft de precisie het aantal cijfers achter de komma c.q. decimale punt weer; voor strings is dat de lengte waarop de string wordt afgekapt, waarna het resultaat wordt aangevuld tot de opgegeven breedte. Het afkappen van relevante informatie kan een bug in een script vormen. De volgende formaattypen zijn mogelijk.

Zo zullen de volgende opdrachten

{ printf "%10.3s\n", 3.1415692}
{ printf "%10.3f\n", 3.1415692} 				

       3.1
     3.142							

expect en andere scripttalen

De behandeling van awk is hier vrij kort gehouden ondanks de vrij complexe materie. De clou is dat een van de belangrijkste redenen om awk binnen een shell script te gebruiken, de printf functie, ook in de korn en bourne again shells is ingebouwd. Ook de andere scripttalen als Perl, TCL, PHP3 en Python, zijn te uitgebreid om hier te behandelen. Perl lijkt enigszins op awk, met nog meer mogelijkheden. Tk maakt in combinatie met TCL of Perl GUI scripts mogelijk.

C programmeurs gebruiken make files, die aangeven welke source files met welke opties moeten worden gecompileerd om binaries en libraries te maken. Make files bevatten weer shell commando's. De m4 macroprocessor is een geval apart, dat te vergelijken is met de C preprocessor, en handig is voor assembly programmeurs. Een m4 file kan willekeurige tekst bevatten plus macrodefinities en macro's. M4 vervangt dan de macro's door hun definitie.

Postscript™ van Adobe wordt een paginabeschrijvingstaal genoemd. Postscript programma's worden geschreven door opmaakprogramma's en uitgevoerd door printers, resulterend in een of meer pagina's gedrukt tekst. Elementen die op elke pagina terugkomen worden eenmalig als een functie gedefinieerd. Verder heeft het wat van Forth weg. Het voordeel is dat de taal onafhankelijk van het type printer is.

Om een script te schrijven dat interactie, zowel in- als uitvoer, pleegt met een ander programma, kun je gebruik maken van Expect, dat weer gebruik maakt van John Ousterhout's Tool Command Language. De syntaxis luidt

expect [ -di ] [ -c script ] [ -f sfile ] ...

De -d optie geeft een hoop diagnostische uitvoer. Met de -i optie gedraagt expect zich als een interactieve shell. Achter -c kan in een heel script (tussen aanhalingstekens) worden opgegeven en met -f kan de naam van de file met het script worden meegegeven. Hieronder volgt een voorbeeld waarin expect wordt gebruikt om een bestand te downloaden via ftp, wat met de shell niet zou lukken.

						#!/usr/bin/expect -f						

# zoals aangegeven in paragraaf 1.3 wordt hierboven
# expect gestart en de rest zijn expect commando's		

spawn ftp localhost
								# Met spawn wordt een extern programma gestart 			

expect -re "Connected.*\n"
expect -re "220.*\n"
expect -re "Name.*:.?"
								# Het expect commando laat expect wachten totdat het
# het externe programma de opgegeven strings uitprint
# of er een time-out of end-of-file optreedt. 
# Na de -re optie volgt een reguliere expressie. 
# \n staat voor een nieuwe regel en \r voor return. 		

send "anonymous\r"
expect "anonymous\r\n"

								# Het send commando stuurt de user naam naar het ftp
# proces. Dat zal de invoer terug echoen.			

expect  {
          -re 331.*\nPassword: {
                                 expect_user -re.*\n
                               }
         }

								# We wachten op de password-prompt van de ftp server
# en dan vraagt het script de gebruiker om zelf 
# het wachtwoord in te vullen. 					

send "$expect_out(0,string)\r"
expect "\r\n"

								# We sturen de invoer van de gebruiker naar de ftp
# server. Die zal het wachtwoord niet laten zien. 		

expect  {
        -re (230.*\n)+.*\n.*\n  {}
        -re (530.*.n)+.*\n      exit
        }
}

								# Nu zijn er twee mogelijk heden: 230. User anonymous
# logged in, of 530. Login incorrect; in het eerste
# geval doen we niets en in het tweede geval stoppen
# we de expect sessie. 						

expect -re "ftp>.?"
send "cd pub\r"
expect "cd pub\r\n"
expect -re "(250.*\n)*250.*successful.*\n"

								# We wachten op de ftp prompt en sturen "cd pub" 
								
expect -re "ftp>.?"
send "ls\r"
expect "ls\r\n"
expect -re "200.*\n150.*\ntotal(.*\n)+226.*\n"

								# We sturen "ls" en krijgen een aantal regels terug, 
# en na de prompt sturen we "get README" 			

expect -re "ftp>.?"
send "get README\r"
expect "get README\r\n"
expect {
 -re local.*\n200.*\n150.*\n226.*\n.*received.*\n {}
 -re local.*\n200.*\n550.*\n                       exit

}								

at en batch

De at faciliteit zorgt ervoor dat opdrachten op een later tijdstip worden uitgevoerd. De syntaxis luidt:

at [ -m ] [ -l ] [ -f file ] [ -q letter ] [ -r job ] tijdstip

De -f optie wordt gevolgd door de naam van het uit te voeren script; als deze optie ontbreekt, dan worden commando's van de standaard invoer gelezen. De uitvoer van het script wordt de gebruiker toegemaild, dus die hoeft op het moment van uitvoering niet ingelogd te zijn. Op de meeste systemen hebben ook gewone gebruikers toestemming om at te gebruiken.

De -m optie zorgt ervoor dat er ook mail wordt verzonden als de opdracht geen uitvoer produceerde. Er wordt voor gezord dat de commando's dezelfde omgevingsvariabelen meekrijgen als op het moment dat at werd aangeroepen.

Het batch commando doet hetzelfde als at, behalve dat commando's pas worden uitgevoerd wanneer de belasting van het systeem voldoende laag is. Die belasting krijg je te zien met uptime. De -q vlag geeft aan in welke queue (wachtrij) de job terecht komt. De queue bepaalt de prioriteit waarmee een taak wordt uitgevoerd: a is de default at queue, b de default batch queue.

De tijd kan worden opgegeven als uumm of uu:mm, desgewenst met am of pm erachter. De liefhebber mag ook now, midnight, noon of teatime gebruiken. Daarachter komt de eventuele datum, die bijvoorbeeld today of tomorrow mag luiden. Als het tijdstip al voorbij is, wordt aangenomen dat het morgen moet zijn en als de dag al geweest is, dan zal de gebruiker wel volgend jaar bedoelen. Enkele voorbeelden:

at 0815am Jan 24, 2002 
at 8:15am Jan 24 
at now + 1 day 
at 5 pm Friday next week  					

Met de -l optie krijg je een lijst van de geplande taken te zien. Met de -r optie kun je een taak verwijderen. Alleen root mag andermans taken annuleren.

cron

Cron is een Unix daemon, een systeemprogramma dat op de achtergrond loopt, die op gezette tijden opgegeven programma's start, terwijl at voor eenmalige opdrachten is; op sommige systemen start cron elke minuut een programma dat kijkt of er nog at jobs te doen zijn. Cron wordt meestal gebruikt door de systeembeheerder om bijvoorbeeld 's nachts backups te draaien, maar is vaak ook voor de andere gebruikers beschikbaar.

Net als at zal cron eventuele uitvoer van een opdracht naar de opdrachtgever mailen, tenzij je de standaard uitvoer omleidt; er wordt doorgaans een regel in een log file geschreven voor uitgevoerde jobs. Een nadeel van cron is dat taken die niet op het aangegeven tijdstip uitgevoerd kunnen worden, bijvoorbeeld omdat de computer down is, zullen worden overgeslagen. Een ander verschil met at is dat je de omgevingsvariabelen mist die worden ingesteld als je inlogt.

De gebruiker maakt gebruik van de crontab opdracht om zijn/haar lijst met cron taken te wijzigen. De syntaxis luidt:

cron [ -u user ] [ -e | -l | -r ]

De verticale balk | geeft in onze syntaxis-notatie aan dat of de -e vlag, of -l of -u moeten worden gebruikt: u dient het evenmin als de rechterhaken over te typen. Met de -u optie kan root andermans cron tabel wijzigen; deze optie kan ook handig zijn in combinatie met su. Met de -r optie wordt een cron tabel verwijderd. Met de -e optie wordt de cron tabel gewijzigd; voor dit doel wordt vi opgestart tenzij de inhoud van de omgevingsvariabele $EDITOR iets anders vermeldt.

Een cron tabel bestaat uit een aantal regels, die afgezien van blanco of commentaarregels een zestal velden bezitten.

De dag van de week of de dag van de maand moeten overeenkomen; het volgende voorbeeld zal op elke vrijdag de 13^e tussen elf uur en middernacht elke minuut de inhoud van de /tmp directory wissen en op 13 november ongeacht de dag van de week. In de plaats van een getal mogen er meerdere voorkomen met komma's, maar zonder spaties ertussen.

  
# een voorbeeld cron tabel				
* 23 13 11 5 find /tmp -exec rm -f {} 2>/dev/null		

basename en dirname

Het basename commando verwijdert het directory pad uit een filenaam en eventueel de extensie. De syntaxis luidt:

basename padnaam [ extensie ]

Als de filenaam niet eindigt op de extensie dan wordt de hele naam weergegeven en ook als de filenaam gelijk is aan de extensie. Die extensie kan een willekeurige string zijn. Er wordt niet gecontroleerd of de file bestaat. Het volgende voorbeeld geeft de voornaam van alle html-bestanden.

for file in `find . print | fgrep .html`
do
  basename $file .html
done								

Het dirname commando geeft het directory pad van een filenaam. De syntaxis luidt:

dirname padnaam

Als er geen slash (/) in de padnaam voorkomt, wordt de huidige directory (.) geretourneerd. Het volgende voorbeeld geeft alle directory's die html-bestanden bevatten, met dien verstande dat alleen de naam en niet de inhoud van de file wordt getest.

find . -print | fgrep .html | xargs -l1 dirname | uniq -c 	

clear

Het commando clear wist de inhoud van het scherm en zet de cursor in de linker bovenhoek. De omgevingsvariabele TERM bevat het type van uw terminal; als clear niet werkt, kijk of uw terminal wordt ondersteund.

sort en uniq

Met sort kunnen bestanden worden gesorteerd en / of samengevoegd. De sorteervolgorde wordt bepaald door de ingestelde taal en de standaardinstelling is dat de hele regel als sorteersleutel wordt gebruikt. De syntaxis luidt:

sort [ -c ] [ -m ] [ -u ] [ -tteken ] [ +pos1 [ -pos2 ] ]
[ -o file ] [ -T directory ] [ file ...]

De volgende opties zijn mogelijk:

Verder kan worden opgegeven dat de velden vanaf pos1 tot en zonder pos2 de sorteersleutel vormen. Als pos2 ontbreekt dan vormt de hele rest van de regel de zoeksleutel. Er wordt geteld vanaf 0. Regels waarvan de eerste i velden gelijk zijn worden gesorteerd op basis van het i + 1^e veld. De posities kunnen van de vorm m.n zijn, waarin m het veldnummer is en n de positie binnen het veld. De volgende opties zijn globaal geldig als ze voor pos1 staan, maar als ze achter een positie staan hebben ze betrekking op dat veld.

Het volgende voorbeeld sorteert het wachtwoordbestand op Group ID en binnen een groep worden de User IDs in omgekeerde volgorde gezet en per UID op het GCOS alias comment veld, dat vaak de volledige naam van de gebruiker en evt. kamernummer en telefoontoestel bevat.

sort -bdft: +3n +2nr -5 /etc/passwd 				

Het uniq commando kan in veel gevallen worden weggelaten en `sort -u' worden gebruikt om dubbele regels te verwijderen. De syntaxis luidt:

uniq [ -u | -c | -d ] [ -kolommen ] [ +tekens ] [ in [ uit ] ]

De -u optie zorgt ervoor dat enkel de regels die niet dubbel voorkomen worden afgedrukt, terwijl de -d optie elke vaker voorkomende regel een keer in de uitvoer verschijnt en met -c worden alle regels voorafgegaan door het aantal keren dat ze voorkomen.

Achter het - teken komt een eventueel aantal kolommen dat voor de vergelijking wordt overgeslagen; achter het + teken komt een aantal tekenposities dat wordt overgeslagen, nadat de voorafgaande kolommen zijn overgeslagen.

Veel commando's geven eerst een titelregel, die we niet mee willen sorteren. In plaats van head (zie paragraaf head en tail) en tail te gebruiken kan het ook met het scriptje `knip'.

read LINE
echo "$LINE" 1>&2
while read LINE
do
  echo "$LINE"
done								

w | knip | knip | sort -f 2>&1 					

cmp, comm en diff

Met het cmp commando kunnen twee files worden vergeleken. De syntaxis luidt:

cmp [ -l | -s ] file1 file2

Standaard wordt het nummer en de inhoud van het eerste byte getoond dat verschilt als octaal getal. Met de -s (silent) optie is er geen uitvoer en kan slechts de exit status worden getest, terwijl -l alle bytes die verschillenden weergeeft.

Cmp is geschikt voor binaire files; comm vergelijkt twee bestanden regel voor regel. De bestanden dienen gesorteerd te zijn. De syntaxis luidt:

comm [ -1 ] [ -2 ] [ -3 ] file1 file2

Zonder vlaggen wordt de uitvoer weergegeven in drie kolommen: in de eerste regels die alleen in file1 voorkomen, in de tweede regels die in file2 voorkomen, en in de derde kolom de gemeenschappelijke regels. De kolommen worden gemarkeerd door de regel met nul, een of twee tab-tekens te beginnen; de uitvoer is niet bijster overzichtelijk. De vlaggen geven de optie een of meerdere kolommen weg te laten, bijv. comm -12 … om alleen gemeenschappelijke regels te zien.

Het diff commando zoekt naar de verschillen tussen twee bestanden. De syntaxis luidt:

diff [ -b ] [ -r ] [ -e ] file1 file2

Met de optie -b worden spaties aan het eind van een regel genegeerd. Met de optie -r worden—als file1 en file2 directory's zijn—alle files in die directory's vergeleken. Met de optie -e wordt de uitvoer in de vorm van commando's voor de ed editor (grootvader van vi) geschreven.

De uitvoer van diff kan worden gebruikt om met het patch tool file1 te veranderen in file2 of andersom. Als een programmeur aan een groot programma een paar regels heeft veranderd, hoeft hij / zij slechts de patch te verspreiden. De uitvoer van diff heeft de volgende vorm:

n1a n3,n4 (regels toevoegen) n1,n2d n3 (regels verwijderen) n1,n2c n3,n4 (regels wijzigen)

Achter een edit commando volgt een lijst van de betroffen regels in file1 met telkens een < ervoor en een lijst regels uit file2 voorafgegaan door een >; bijv. als in de ene file op regel 13 een fiets staat waar de andere een rijwiel heeft:

13c13 < fiets --- > rijwiel

column

Het column commando (BSD, Linux) kan tekst in kolommen verdelen om een nette uitvoer te geven. De syntaxis luidt:

column [ -t ] [ -x ] [ -c kolommen ] [ -s teken ] [file...]

De opties zijn:

Op de volgende manier kan de uitvoer van find op een ls-achtige manier in kolommen worden gezet.

find . -mindepth 1 -print | xargs -l1 basename | \
  sort -u | column 						

In het volgende voorbeeld wordt de uitvoer van ls van een titelregel voorzien.

( printf \
  "PERM LINKS OWNER GROUP SIZE MONTH DAY HH:MM/YEAR NAME\n" 
  /bin/ls -l | sed 1d
) | column -t							

colrm, cut, paste, join

Het colrm commando van BSD Unix verwijdert kolommen uit elke regel van de standaard invoer. Met kolommen worden hier tekenposities bedoeld. De syntaxis luidt:

colrm [ startpositie [eindpositie ] ]

De posities worden geteld vanaf 1. Als alleen de startpositie wordt opgegeven wordt de rest van de regel verwijderd, anders van start tot en met eind.

System V Unix kent een cut commando dat ongeveer hetzelfde doet, met de volgende syntaxis:

cut [ -b | -c | -f ] lijst [-d teken ] [ file ...]

De opties zijn als volgt:

Achter de -b, -c of -f optie volgt een lijst met veldnummers die in de uitvoer moeten worden meegenomen. Dit kan een reeks nummers zijn, gescheiden door komma's zonder spaties ertussen. Voor een enkel getal kan ook een bereik start-eind staan, waarbij de start of het eind ook mogen worden weggelaten om de rest van de regel aan te duiden. Zo doen de volgende twee regels hetzelfde

ls -al | colrm 42 54   
ls -al | cut -b -41,55-						

De volgende opdrachten doen niet hetzelfde, omdat de uitvoer van ls niet door tabulatie-tekens gescheiden is, maar door rijen spaties.

ls -al | awk '{ print $9}' 
ls -al | cut -f 9 -d ' ' 					

Om het effekt van de awk regel te bereiken doe je

ls -al | sed -e 's/[ ][ ]*/ /g' | cut -f 9 -d ' ' 		

Op de volgende manier kun je een directory listing sorteren op extensie, waarbij functies uit een voorbeeld in paragraaf sed, editen vanuit een script worden gebruikt. Voor bash is de optie -e vereist.

# optioneel argument: directory naam 

  ls $1 | while read
  	  do
	    echo -e "`extension "$REPLY"`""\t""$REPLY"
	  done | sort -df | cut -f 2 				

Het omgekeerde van cut is paste. Hiermee worden regels uit meerdere files samengevoegd tot een regel, gescheiden door tabs. Paste is wat beperkter dan het join commando. De syntaxis luidt:

paste [ [ -s ] -d lijst ] file ...

De opties zijn als volgt:

Het volgende voorbeeld geeft een lijst bestanden in drie kolommen.

ls | paste - - - | column -t 					

Met join worden twee tekstbestanden samengevoegd, die vooraf gesorteerd moeten zijn. Join voegt regels uit beide bestanden samen met dezelfde inhoud van het sleutelveld. Het sleutelveld is standaard het eerste veld; velden worden gescheiden door spaties of tabulatie-tekens. Join is een standaard operatie voor databases.

De uitvoer bevat alle velden van beide bestanden, en het sleutelveld wordt maar één keer gekopieerd. Als een sleutelveld in de eerste file n keer voorkomt en m keer in de tweede, dan zal de uitvoer n × m regels met deze waarde bevatten. De syntaxis luidt:

join [ -a filenr | -v filenr ] [-e string ] [-o lijst ] [-t teken ]
[ -j [filenr] veldnr | -1 veldnr -2 veldnr ] file1 file2

Join bezit een aantal opties:

Met behulp van join maken we een korte variant op het voorbeeld van paragraaf enkele voorbeelden.

# sorteer de wachtwoord file op login naam		
sort </etc/passwd >een
# knip de titelregels uit lijst van gebruikers, 
	# scheid de velden door dubbele punt en sorteer 	
w | ( read; read; cat) | sed -e 's/[ ][ ]*/:/g' \
| sort >twee
# voeg de bestanden samen en maak er nette tabel van
(echo "USER:FULL NAME:TTY"; join een twee -t ':' \
  -o 1.1,1.5,2.2 ) | column -t -s ':'; rm -f een twee		

head en tail

Na een aantal opdrachten die velden uit bestanden manipuleren, zijn er nog een paar die regels uit tekst filteren. Naast grep hebben we head en tail die respectievelijk de eerste en de laatste paar regels van een bestand laten zien; standaard zijn dat tien (10) regels. De syntaxis luidt:

head [ -aantal | -n aantal ] [ file ...]

tail [ [ + | - ] aantal [ l | b | c ] ] [-f ] [-r ] [file ]

tail [ -c aantal | -n aantal ] [file ]

De opties zijn als volgt:

De GNU versie van head kent een aantal van de opties van tail. Het eerste voorbeeld geeft alleen de namen van de bestanden; het tweede is equivalent met (read; read; cat).

head -0 * 
tail -n +3l							

split en dd

Een heel andere manier om een bestand in regels te splitsen is split, dat meerdere output files aanmaakt van gelijke lengte. De syntaxis luidt:

split [ - [l]aantal | [-b]aantal [k | m]] [file [prefix ] ]

De namen van de output files beginnen met de opgegeven prefix. Zonder prefix heten ze xaa, xab, … De opties zijn:

Een gesplitste file kan worden samengevoegd met cat x* >file.

De functie van dd wordt omschreven als `convert and copy', maar omdat cc al bestond, is voor `disk dumper' gekozen. Het wordt vooral gebruikt voor direkte in- en uitvoer naar een fysiek randapparaat, omdat het niet regels maar records met vaste lengte kopieert. De syntaxis luidt:

dd [ optie=waarde...]

Zonder verdere argumenten lijkt het op cat, maar dd kent een respektabele lijst opties:

De GNU versie kent de opties files=, iseek= en oseek= niet. Het volgende voorbeeld misbruikt dd voor string manipulatie.

echo "Hello, world" | dd bs=1 skip=7 count=6 2> >/dev/null 

env

Het commando env is een aanvulling op set, waarmee een omgevingsvariabele kan worden ingesteld voor de duur van één commando. De syntaxis luidt:

env [ - | -i ] [ naam=waarde...] [programma [argumenten ] ]

Env start het programma, dat de opgegeven namen met de bijbehorende waarden als omgevingsvariabelen meekrijgt. Met de optie - alias -i worden de bestaande omgevingsvariabelen ontzichtbaar voor het programma.

Env zonder argumenten geeft de waarde van alle omgevingsvariabelen, net als het commando printenv (zie paragraaf printenv).

expand, unexpand en tabs

Expand is een hulpmiddel om tabulatie-tekens in een tekstbestand te vervangen door spaties met behoud van paginaindeling. Programmeurs gebruiken het bijvoorbeeld als een printer tabs niet goed verwerkt. Unexpand vervangt reeksen spaties door tab-tekens, wat ruimte bespaart. De syntaxis luidt

expand [ - [t]tabstops] [ file ...]

unexpand [ -a | -t tabstops ] [ file ...]

Posities worden geteld vanaf 1. Standaard wordt een tabstop om de 8 posities aangenomen. Met de optie -t kan een andere waarde worden opgegeven. Het is ook mogelijk om de lijst van tabstops expliciet op te geven, gescheiden door komma's, als ze op ongelijke afstanden voorkomen. Unexpand vervangt alleen de spaties totaan het eerste afdrukbare teken, of alles als de optie -a is gespecificeerd.

In vi kun je de tabstops zetten met :set ts=n; gerelateerde instellingen zijn :set ai (automatisch inspringen) en :set sw=m (inspringdiepte). Om de tab-instellingen te wijzigen op terminals die dit ondersteunen wordt het commando tabs gebruikt, met de syntaxis:

tabs [ -code | -n | n1,…] [-Tterm ] [+mn ]

tabs [-Tterm ] [+m [n]] n1 [,n2...]

De opties zijn als volgt:

file

Het commando file onderzoekt het begin van een file en probeert daaruit af te leiden wat voor type bestand het is. Dit is iets betrouwbaarder dan op de extensie van de filenaam af te gaan, maar het blijft gissen. Als uw systeem een bepaald soort document niet herkent, kunt u zelf patronen toevoegen aan /etc/magic. De syntaxis luidt:

file [ -c ] [ -f ffile ] [ -m mfile ] [file ...]

De opties zijn als volgt:

fold en fmt

Fold breekt lange tekstregels af, zodat de rest op de volgende regel terechtkomt. De syntaxis luidt:

fold [-bs ] [-w lengte ] [file ...]

De volgende opties worden herkend:

Fmt is een simpel programma uit BSD Unix om een tekstbestand wat netter op te maken met een standaard regellengte van 72 (75 voor GNU). Blanco en ingesprongen regels blijven behouden. Het programma pr is gemaakt om tekst in kolommen te zetten met kop- en voetregels voor het afdrukken. Voor C code is er indent, dat de lay-out van een programma helemaal kan omgooien. De syntaxis luidt:

fmt [-opties ] [file ...]

De oude BSD versie kent geen opties; de GNU versie heeft o.a.:

install

Het commando install commando wordt het meest gebruikt in make files om bestanden naar hun bestemming te kopiëren. De vergelijking van de man pages laat zien dat de System V en GNU uitvoeringen sterk verschillen. De syntaxis luidt ongeveer:

install [-f ] [-m mode ] [-u user ] [-g groep ] file directory

Enkele van de opties:

look

Look print alle regels in een gesorteerd tekstbestand die met de opgegeven string beginnen. Het maakt gebruik van een binair zoekalgorithme, waardoor het veel sneller is dan fgrep, maar ook beperkter in zijn functionaliteit. De syntaxis luidt:

look [-d ] [-f ] string [file ]

Tenzij een bestand is opgegeven, kijkt look in het standaardwoordenboek, bijv. /usr/dict/words of /usr/share/dict/words. Enkele opties zijn:

mail

Mail is het standaard interactieve e-mail programma voor Unix gebruikers. Er zijn inmiddels e-mail clients met heel wat meer features, maar mail kan gebruikt worden om berichten te versturen vanuit een programma. De sterk vereenvoudigde syntaxis luidt:

mail [-s onderwerp ] [adres ...]

Als het adres ontbreekt, dan wordt mail gebruikt om interactief te binnengekomen post te lezen en eventueel te wissen; met een adres zal mail een bericht van de standaard invoer lezen en versturen met de eventuele onderwerp-regel (graag tussen aanhalingstekens als er spaties in voorkomen). Als er meerdere ontvangers zijn, moeten de adressen met komma's worden gescheiden.

mesg

Mesg wordt meestal in ~/.profile (zie paragraaf hallo) gebruikt om het ontvangen van berichten op de terminal met talk of write toe te staan of te blokkeren. De syntaxis luidt:

mesg [ n | y ]

Met y worden berichten aan u doorgegeven, met n niet. Zonder argument geeft mesg de momentane instelling. De volgende listing laat zien dat er van twee ingelogde gebruikers een mesg aan heeft staan en de ander uit.

crw-rw-rw- 1 root root 3, 0 Jun 5 19:29 /dev/ttyp0 crw--w---- 1 daniel tty 3, 1 Jun 5 19:26 /dev/ttyp1 crw------- 1 radical tty 3, 2 Jun 5 19:31 /dev/ttyp2 crw-rw-rw- 1 root root 3, 3 May 18 00:44 /dev/ttyp3

od en strings

Od wordt gebruikt om de inhoud van binaire files in octaal of andere formaten weer te geven. De vereenvoudigde syntaxis luidt:

od [- [ b ] [ c ] [ d ] [ h ] [ o ] [ x ] ] [-A radix ] [-j bytes ] [-N bytes ] \
[-t formaat ] [file ]

Er zijn onder andere de volgende opties:

Strings is een ruw tooltje om tekstfragmenten uit binaire bestanden, met name programma's, te filteren. De syntaxis luidt:

strings [- [a] ] [- [n]lengte] [-t d | o | x ] [ file ...]

De opties luiden:

printenv

Printenv drukt de waarde van omgevingsvariabelen af. De syntaxis luidt:

printenv [ variabele ...]

Zonder argumenten worden alle variabelen afgedrukt, net als met set; als de namen van variabelen worden meegegeven, dan worden die afgedrukt. printenv TERM doet vrijwel hetzelfde als echo $TERM.

De exit status is 0 (true) als alle variabelen bestaan en 1 (false) als er één ongedefinieerd is.

sleep

Sleep onderbreekt de uitvoering van een programma tijdelijk. De syntaxis luidt:

sleep seconden

Sleep wordt vooral gebruikt om in een oneindige lus de processor niet nodeloos te belasten in de trant van

while true
do
  if [ er_is_post ] 
  then
    lees_post
    break
  sleep 10
done								

su

Met het substitute user kan een nieuwe shell worden opgestart onder een andere naam; standaard is dat root, ook wel eens als superuser aangeduid. Na een exit commando komt u weer terug in de oude shell. Su vraagt uiteraard om het wachtwoord, tenzij het door root wordt uitgevoerd. Het wordt ook vaak gebruikt om een programma juist minder privileges te geven voor de veiligheid. De syntaxis luidt:

su [- ] [naam ] [-c commando ]

Standaard erft de nieuwe shell de oude omgeving (directory en variabelen), maar de - optie maakt een login shell en voert ~/.profile uit e.d. Met de -c optie wordt in plaats van een interactieve shell een enkel commando uitgevoerd. Vergelijk eens de volgende twee opdrachten.

su -c "whoami "
su -c "who am i" 						

tee

Tee vormt een t-stuk in een pijpleiding. Het is een eenvoudig filter dat de standaard invoer behalve naar de uitvoer ook naar de opgegeven files kopieert. Zie ook paragraaf pijpleidingen. De syntaxis luidt:

tee [-a ] [-i ] [ file ...]

De opties luiden:

time

Time kan zowel een intern shell commando als extern programma zijn. Het voert een programma uit en geeft weer hoeveel tijd het gekost heeft als verstreken tijd en het aantal seconden dat de computer eraan heeft besteed in de user en system modus. De syntaxis luidt:

time commando [ argument ...]

tr

Tr is een eenvoudig filter waarmee tekens in een tekstbestand door andere vervangen kunnen worden zonder de kracht of complexiteit van bijvoorbeeld sed; de bewerkte standaard invoer verschijnt op de standaard uitvoer. De Sytem V, BSD en GNU versies lopen nogal uiteen. De syntaxis luidt ongeveer:

tr [-c ] [-s ] [-d ] string1 [string2 ]

De opties zijn:

De opties kunnen ook gecombineerd worden. In de strings mogen de backslash escapes van paragraaf aanhaling en de karakter klassen van paragraaf grep en reguliere expressies worden gebruikt. Tevens kunnen reeksen tekens worden aangegeven met begin-eind en [teken*aantal].

wc

Wc is een eenvoudig tooltje om de lengte van een tekst te tellen. De syntaxis luidt:

wc [-l ] [-w ] [-c ] [ file ...]

De opties zijn:

Standaard worden regels, woorden en bytes of tekens geteld. Als er meerdere files worden opgegeven, dan volgt nog een regel met het totaal over alle files (verwarrend als u een bestand total hebt :-)

yes

Yes is een simpel programmaatje, dat zolang y of een andere string produceert totdat het wordt afgebroken. De syntaxis luidt:

yes [string ]

Het wordt vooral gebruikt in pijpleidingen, zoals yes n | fsck / Fsck zal vragen of u wel zeker weet dat u het root file systeem wilt controleren; omdat dat riskant is op een aktief systeem wordt die vraag automatisch met n(ee) beantwoord.