Denna handledning utforskar hur man definierar och hanterar både indexerade och associativa matriser (arrayer) i Bash.
I Bash kan du använda arrayer för att organisera och lagra samlingar av element. Dessa arrayer är endimensionella. Till skillnad från programmeringsspråk som C och C++, där arrayer vanligtvis endast innehåller element av samma datatyp, kan en Bash-array innehålla både heltal och strängar, beroende på ditt behov.
I denna genomgång kommer du att upptäcka hur du deklarerar en Bash-array och hur du når dess komponenter. Du kommer sedan lära dig hur man itererar genom en array, och hur man lägger till nya element. Till sist kommer vi undersöka associativa arrayer i Bash.
Nu börjar vi!
⚙ Är du intresserad av att börja koda? Här är vad du behöver:
Hur man skapar en Bash-array
I detta avsnitt får du lära dig syntaxen för att definiera en Bash-array, tillsammans med praktiska exempel.
Syntax för Bash-arraydeklaration
En array i Bash deklareras med följande struktur:
$ arrayNamn=(element1 element2 ... elementN) # arrayNamn är namnet på arrayen # element1 till elementN är de N elementen i arrayen
I koden ovan representerar arrayNamn namnet på den array som innehåller N elementen element1 till elementN.
Elementen i arrayen omges av parenteser (). Observera också att elementen separeras med ett blanksteg. Precis som med alla Bash-variabler, får det inte finnas något blanksteg före eller efter likhetstecknet =.
📑 I de flesta andra programmeringsspråk brukar elementen i en array eller liknande samlingar separeras med kommatecken, men i Bash används alltså blanksteg som avgränsare.
I Bash benämns sådana arrayer, där elementen nås via ett index, som indexerade arrayer.
Skapa indexerade arrayer i Bash
Låt oss skapa en array för priser, som innehåller numeriska värden.
$ priser=(24 27 18 30 15)
Som syntaxen visar separeras talen i prisarrayen med blanksteg, omgivna av parenteser och utan blanksteg före eller efter likhetstecknet =.
I Bash används kommandot echo för att skriva ut värdet av en variabel. Genom att ange $variabelNamn skrivs värdet av variabelNamn ut. Om du däremot använder namnet på arrayen, ser du att endast det första elementet skrivs ut.
$ echo $priser 24
Bash-arrayer är nollindexerade. Det betyder att det första elementet har index 0, det andra index 1 och så vidare. Du kan även använda negativ indexering, där det sista elementets index är -1.
Vad händer om du försöker nå ett element vid ett specifikt index? Låt oss försöka skriva ut elementet vid index 1.
$ echo $priser[1] 24[1]
Varför blir utskriften 24[1]? 🤔 Det beror på att Bash ersätter $priser med 24, det första elementet i arrayen, och [1] skrivs ut som det är.
För att skriva ut elementet vid ett visst index används parameterexpansion på formen ${priser[index]}.
$ echo ${priser[1]}
# 27
$ echo ${priser[2]}
# 18
För att skriva ut alla element i arrayen används @ istället för ett specifikt index.
$ echo ${priser[@]}
24 27 18 30 15
Låt oss nu skapa en array med strängar. Genom att köra följande kommando skapas en indexerad array:
$ declare -a frukter
Alternativet -a signalerar att det är en indexerad array. Du kan fylla i arrayen med ett element i taget genom att tilldela elementet till ett specifikt index enligt följande:
$ frukter[0]="körsbär" $ frukter[1]="bär" $ frukter[2]="äpple" $ frukter[3]="päron" $ frukter[4]="melon" $ frukter[5]="apelsin"
För att skriva ut alla element i arrayen används ${frukter[@]}.
$ echo ${frukter[@]}
körsbär bär äpple päron melon apelsin
Nå elementen i en Bash-array
Du kan nå elementen i en array på följande sätt:
- Genom att iterera genom arrayen och komma åt elementen direkt
- Genom att iterera genom arrayens index och komma åt elementen via indexen
Iterera genom arrayen och kom åt element
Om du har programmerat i Python har du kanske använt en for-loop med följande syntax:
for element in some_list:
print(element)
Låt oss se motsvarande konstruktion i Bash.
Vi vet att ${priser[@]} expanderar till alla elementen i prisarrayen. Och ${priser[@]} ger oss värdena på elementen.
En for-loop i Bash liknar for-loopen i Python, men satserna i loopkroppen måste omges av do och done enligt följande:
$ for pris in ${priser[@]}
> do
> echo $pris
> done
Eftersom vi använder kommandot echo och skriver ut värdet av den itererade variabeln pris, får vi följande utskrift:
# utskrift 24 27 18 30 15
Nå element via arrayindex
Ett annat sätt att iterera genom arrayer är att använda elementens index. Detta liknar for-loop konstruktionen i Python som använder funktionen range():
for i in range(len(some_list)):
print(i)
För att få en lista över de index du ska iterera över kan du placera ett utropstecken ! framför arraynamnet i parameterexpansionen. Detta ger dig en lista över alla giltiga index för arrayen, som visas:
$ echo ${!priser[@]}
0 1 2 3 4
Arrayen priser innehåller 5 element, så index börjar på 0 och går upp till 4.
Sedan kan vi iterera genom listan över index och komma åt elementen vid varje index. För index i är ${priser[i]} elementet vid index i.
$ for i in ${!priser[@]}
> do
> echo ${priser[i]}
> done
Ovanstående loop skriver ut alla element i arrayen.
# utskrift 24 27 18 30 15
💬 Här, efter att ha nått varje element, utför vi en enkel operation för att skriva ut dess värde. I allmänhet kan vi ha vilken typ av bearbetning som helst av elementen.
Lägg till element i en Bash-array
I arrayen priser har vi fem element (vid index 0, 1, 2, 3 och 4). Om du vill lägga till ett element i slutet av arrayen vid index 5, kan du göra det enligt följande:
$ priser[5]=21
Vi ser att 21 har lagts till i slutet av priser-arrayen.
$ echo ${priser[@]}
24 27 18 30 15 21
Det är dock smidigare att lägga till det nya elementet sist utan att komma ihåg indexet, eller antalet element som redan finns i arrayen.
Du kan använda arrayNamn+=(element(s)) för att lägga till ett eller flera element i en array, enligt följande:
$ priser+=(10)
Om vi skriver ut arrayen priser nu, ser vi att 10 har lagts till sist.
$ echo ${priser[@]}
24 27 18 30 15 21 10
Låt oss nu lära oss hur man definierar associativa arrayer i Bash.
Associativa arrayer i Bash
Om du vill definiera relationer i form av nyckel-värdepar kan du använda en associativ array. Du kan deklarera en associativ array med följande allmänna syntax. Observera att vi använder alternativet -A istället för -a.
$ declare -A frukt_priser
Du kan lägga till element i den associativa arrayen genom att ange nyckeln och motsvarande värde. Här har vi lagt till namnen på frukterna som nycklar och talen från priser-arrayen som värden.
$ frukt_priser[körsbär]=24 $ frukt_priser[bär]=27 $ frukt_priser[äpple]=18 $ frukt_priser[päron]=30 $ frukt_priser[melon]=15 $ frukt_priser[apelsin]=21
Så, hur får vi tag i elementen i en associativ array?
Precis som du skulle söka upp ett värde via motsvarande nyckel i en Python-ordbok kan du nå värdena i en associativ array med hjälp av nycklarna.
$ echo ${frukt_priser[bär]}
# 27
Vi ser att ${frukt_priser[@]} expanderar till värdena och ${!frukt_priser[@]} expanderar till nycklarna.
$ echo ${frukt_priser[@]}
# Utskrift: 18 27 21 24 30 15
$ echo ${!frukt_priser[@]}
# Utskrift: äpple bär apelsin körsbär päron melon
Obs: Ordningen på elementen är inte samma som ordningen vi lade till dem i. Det beror på att, till skillnad från indexerade arrayer, är associativa arrayer inte ordnade samlingar. Istället jobbar de med relationen mellan nycklar och värden. Därför är nycklarna i associativa arrayer vad index är för indexerade arrayer.
Du kan även iterera genom den associativa arrayen och komma åt nycklarna enligt följande:
$ for nyckel in ${!frukt_priser[@]}
> do
> echo $nyckel
> done
# Utskrift äpple bär apelsin körsbär päron melon
Följande loop visar hur du kommer åt värdena.
$ for värde in ${frukt_priser[@]}
> do
> echo $värde
> done
# Utskrift 18 27 21 24 30 15
Även om det rekommenderas att använda arrayNamn[nyckel]=värde kan du även deklarera den som en sekvens enligt följande:
declare -A arrayNamn arrayNamn=(nyckel1 värde1 nyckel2 värde2 ... nyckelN värdeN)
På det här sättet drar Bash slutsatsen att det första elementet är den första nyckeln, det andra elementet är det första värdet och så vidare.
Sammanfattning
Jag hoppas att du nu förstår hur man skapar och hanterar Bash-arrayer. Här är en snabb sammanfattning av vad du har lärt dig.
- Du kan deklarera en indexerad array i Bash med syntaxen
arrayNamn=(element1 element2 element3 … elementN)eller genom att köradeclare -a arrayNamnoch lägga till element i arrayen. - För att nå elementen kan du iterera genom arrayen med
${arrayNamn[@]}. Alternativt kan du få listan över alla giltiga index med parameterexpansionen${!arrayNamn[@]}. - Slutligen har du lärt dig att deklarera en associativ array för att lagra nyckel-värdepar i Bash.
Kolla in vår handledning om loopar i Bash nästa gång.