12.1 Fält

Bash kan hantera så kallade fält. Ett fält är en slags variabel som kan innehålla många olika värden. Värdena skiljs åt med hjälp av olika nummer som kallas för deras index. Index kan vara allt från 0 och uppåt. Kommandot fält[n]=värde lagrar värdet värde i fältet fält under index n. Vi ger ett exempel:$ MANAD[3]=mars
$Nu har vi lagrat värdet mars i fälet MANAD och gett det index 3. För att få tillbaka värdet gör man så här:$ echo Nu är det ${MANAD[3]}
Nu är det mars
$För att referera till värdet med index n i fältet fält skriver man alltså ${fält[n]}.

Låt oss använda ett annat index i samma fält:$ MANAD[4]=april
$Nu finns de båda värdena mars och april lagrade under index 3 respektive 4 i fältet MANAD.$ echo Efter ${MANAD[3]} kommer ${MANAD[4]}
Efter mars kommer april
$

Man kan tilldela flera fältvärden samtidigt på följande sätt:$ VECKODAG=(måndag tisdag onsdag torsdag fredag lördag söndag)
$Det första värdet inom parenteserna får index 0, det andra index 1 osv.$ echo Vilodagen heter ${VECKODAG[6]}
Vilodagen heter söndag
$Om man skriver * eller @ som index, så får man alla värdena i fältet:$ echo ${VECKODAG[*]}
måndag tisdag onsdag torsdag fredag lördag söndag
$(Detta är analogt med parametrarna * och @, som står för samtliga argument till ett Bashprogram. Citationstecknen har motsvarande verkan i fallet med fält.)

Man kan ange index då flera fältvärden tilldelas samtidigt:$ MANAD=([1]=januari februari [5]=maj juni [12]=december)
$Värdet januari lagras under index 1. Vi gav inget index för februari ovan, så det lagras under det följande indexnumret, nämligen 2. Värdena maj och juni lagras under index 5 respektive 6. Slutligen lagras december under index 12.$ echo ${MANAD[6]}
juni
$ allaargument "${MANAD[@]}"
Totalt 7 argument.
Ett argument är januari.
Ett argument är februari.
Ett argument är mars.
Ett argument är april.
Ett argument är maj.
Ett argument är juni.
Ett argument är december.
$

Här är ett enkelt program som använder fält:

#!/bin/bash
TAL=([1]=ett två tre fyra fem sex sju åtta nio tio)
echo ${TAL[$1]}

Programmet tar emot ett argument, som ska vara ett tal mellan 1 och 10. Talet skrivs sedan ut med bokstäver:$ skrivtal 3
tre
$Med hjälp av ett andra fält kan vi lära programmet att skriva ut alla tal upp till 99:

#!/bin/bash
ENTAL=([1]=ett två tre fyra fem sex sju åtta nio tio elva \
       tolv tretton fjorton femton sexton sjutton arton nitton)
TIOTAL=([2]=tjugo trettio fyrtio femtio sextio sjuttio åttio nittio)
if (( $1>19 )) ; then
  echo -n ${TIOTAL[$1/10]}
  set $(( $1%10 ))
fi
echo ${ENTAL[$1]}

Låt oss köra programmet en par gånger innan vi förklarar det:$ skrivtal 57
femtiosju
$ skrivtal 3
tre
$ skrivtal 14
fjorton
$För att slippa mata in alla de 99 olika värdena i programmet har vi separerat tiotalssiffran från entalssiffran för alla tal från och med 20. När argumentet är 57 skrivs ordet ''femtio'' ut av det första echo-kommandot och ordet ''sju'' av det andra echo-kommandot. Flaggan -n anger att inget nyrad-tecken ska skrivas ut. Därför hamnar orden ''femtio'' och ''sju'' efter varandra på samma rad. Ordet ''femtio'' är värdet med index 5 i fältet TIOTAL. Som index anger vi $1/10, dvs första argumentet delat med 10. Detta avrundas nedåt till ett heltal, och ger därför talets första siffra (förutsatt att talet inte är större än 99). Lägg märke till att beräkningen av index sker automatiskt, dvs man behöver inte använda $((...)). När vi ''förbrukat'' första siffran kastar vi bort den genom att med ett set-kommando ändra första argumentet till det uträknade värdet av $1%10. Procenttecknet står för ''resten vid heltalsdivision'', och resten vid division med 10 är talets sista siffra.

På motsvarande sätt kan vi lära programmet att klara alla tal upp till 999:

#!/bin/bash
ENTAL=([1]=ett två tre fyra fem sex sju åtta nio tio elva \
       tolv tretton fjorton femton sexton sjutton arton nitton)
TIOTAL=([2]=tjugo trettio fyrtio femtio sextio sjuttio åttio nittio)
(( $1>99 )) && echo -n ${ENTAL[$1/100]}hundra && set $(( $1%100 ))
(( $1>19 )) && echo -n ${TIOTAL[$1/10]} && set $(( $1%10 ))
echo ${ENTAL[$1]}

Om talet är tresiffrigt, så skrivs första siffran ut följt av ordet ''hundra'', varefter bara de båda sista siffrorna behålls. Sedan fungerar programmet som tidigare, men det är något mer kompakt skrivet.$ skrivtal 88
åttioåtta
$ skrivtal 388
trehundraåttioåtta
$ skrivtal 701
sjuhundraett
$