6.2 De första programmen

UNIX-skal är inte bara interaktiva kommandotolkar utan även fullfjädrade programmeringsspråk. I detta avsnitt ska vi berätta hur man kan programmera i Bash.

Det är inte svårt att göra egna program i Bash. I princip placerar man bara en följd av Bash-kommandon i en fil. Kommandona utförs i tur och ordning när programmet körs. Låt oss som exempel konstruera ett program som skriver ut texten ''Hej, världen!''. Så här skulle man göra det från prompten:$ echo 'Hej, världen!'
Hej, världen!
$ Men nu ska vi istället skapa en fil som innehåller detta kommando. Filen kallar vi för hejvärlden. I UNIX har man som konvention att på första raden i ett sådant program skriva tecknen #! och därefter ange vilken tolk som ska köra det. Filen ska alltså se ut så här (skapa den med hjälp av Emacs och ge den namnet hejvärlden):

#!/bin/bash
echo 'Hej, världen!'

Nu är det dags att prova programmet. Först måste vi sätta filrättigheterna så att hejvärlden blir ett körbart program:$ ls -l hejvärlden
-rw-rw-r--   1 göran    göran          33 nov 10 00:29 hejvärlden
$ chmod a+x hejvärlden
$ ls -l hejvärlden
-rw-rw-r--   1 göran    göran          33 nov 10 00:29 hejvärlden*
$ Programmet kan nu köras på samma sätt som andra UNIX-program som tex date och cd, vi ska helt enkelt ge kommandot hejvärlden:$ hejvärlden
Hej, världen!
$ För att detta ska fungera måste dock den nuvarande katalogen finnas i sökvägen för program. Vi kontrollerar:$ echo $PATH
/usr/bin:/bin:/usr/bin/X11:/usr/local/bin:/usr/games:.
$ Ja, punkten i slutet av PATH står för den nuvarande katalogen. Om den nuvarande katalogen inte funnits med, så hade jag varit tvungen att ange sökvägen till hejvärlden, tex så här:$ ./hejvärlden
Hej, världen!
$ Om det hade funnits ett annat program med namnet hejvärlden i någon av de kataloger som räknas upp före punkten i PATH, så skulle det programmet köras istället. Därför kan det vara värt att skriva ./hejvärlden även om den nuvarande katalogen finns i PATH. Men det bästa sättet är att placera programmen i en katalog med namnet bin i sin hemkatalog och sedan se till att PATH innehåller denna katalog. I så fall kan vi anropa programmen utan att ange sökvägen till dem.$ mkdir bin
$ mv hejvärlden bin
$ PATH=/home/göran/bin:$PATH
$ echo $PATH
/home/göran/bin:/usr/bin:/bin:/usr/bin/X11:/usr/local/bin:/usr/games:.
$ hejvärlden
Hej, världen!
$ (Denna ändring av PATH finns inte kvar när jag loggar in nästa gång. Om ändringen ska vara permanent, så ska den göras i filen .bash_profile - se avsnitt 6.4.) I fortsättningen förutsätter vi att alla program skapas med hjälp av en textredigerare och sparas i katalogen bin. Dessutom ska filerna som innehåller programmen naturligtvis vara exekverbara.

Man kan använda variabler i Bash-program, precis som vid prompten. Vi minns från avsnitt 6.1 att man måste sätta ett dollartecken framför variabelnamnet om man vill referera till variabelns värde. Vi ska nu skriva ett program som frågar efter ett namn och därefter ger en artig hälsning. Så här kan det se ut:

#!/bin/bash
echo 'Ange ditt namn:'
read NAMN
echo "Hej, $NAMN!"

Kommandot read NAMN läser in en text och sätter värdet av variabeln NAMN till denna text. På sista raden av programmet använder vi citationstecken i stället för apostrofer, för annars byter Bash inte ut $NAMN mot värdet av NAMN. Vi antar att programmet finns sparat i en exekverbar fil med namnet hej i katalogen bin. Låt oss prova:$ hej
Ange ditt namn:
Göran
Hej, Göran!
$ Det gick ganska bra. Men det vore bättre om man fick skriva sitt namn på samma rad som innehåller texten ''Ange ditt namn:''. Ett sätt att uppnå detta är att ge echo flaggan -n, för då skriver echo inte ut något nyrad-tecken efter texten. Ett annat sätt är att med hjälp av flaggan -p (''prompt'') låta read skriva ut texten. Vi ändrar programmet till följande:  

#!/bin/bash
read -p 'Ange ditt namn: ' NAMN
echo "Hej, $NAMN!"

Därefter kör vi programmet igen:$ hej
Ange ditt namn: Göran Andersson
Hej, Göran Andersson
$

Man kan också låta de egna Bash-programmen läsa in argument. Det första argumentet skrivs $1, det andra $2 osv. Vi gör en ny version av programmet hej, som tar emot namnet i form av ett argument istället:  

#!/bin/bash
echo "Hej, $1!"

Då fungerar det så här:$ nyhej Kalle
Hej, Kalle!
$ nyhej Nisse Nilsson
Hej, Nisse!
$ I det andra fallet ovan är ''Nisse'' det första argumentet och ''Nilsson'' det andra; programmet skriver bara ut det första argumentet.

Man kan säga att 1 fungerar som en variabel i Bash, och dess värde (som man får genom att skriva $1) är det första argumentet. Det finns ett antal andra sådana så kallade parametrar i Bash. Parametrarna 2, 3... står för det andra respektive tredje argumentet osv. (För att få värdet av tex det trettonde argumentet måste man skriva ${13}. Om man skriver $13, så tolkas det som värdet av den första parametern följt av en trea.) Parametern 0 står för det nollte argumentet, som är det namn programmet anropades under. Parametern * står för samtliga argument, från det första till det sista, separerade av mellanslag, och # står för antalet argument. Här är ett exempelprogram.

#!/bin/bash
echo "Totalt $# argument."
echo "Det trettonde argumentet är ${13}."

Programmet talar först om hur många argument det fick, och skriver sedan ut sitt trettonde argument. Vi sparar programmet under namnet argument i katalogen bin.$ argument 1 2 3 4 5 6 7 8 9 10 11 12 Tretton 14
Totalt 14 argument.
Det trettonde argumentet är Tretton.
$ argument 1 2 3 4 5 6 7 8
Totalt 8 argument.
Det trettonde argumentet är .
$ Vid den andra körningen ovan fanns det färre än tretton argument, och då har parametern 13 inget värde.

Vi ändrar programmet nyhej till följande:

#!/bin/bash
echo "Hej, $*!"

Nu skriver programmet ut samtliga argument i stället för bara det första.$ nyhej Kalle
Hej, Kalle!
$ nyhej Nisse Nilsson
Hej, Nisse Nilsson!
$