En guide till Bash Arrays

Spread the love

I den här guiden om Bash-matriser lär du dig hur du deklarerar och arbetar med indexerade och associativa matriser i Bash.

I Bash kan du skapa arrayer för att lagra en samling element. Bash-arrayer är endimensionella samlingar. I programmeringsspråk som C och C++ är arrayer samlingar av element av samma datatyp. Men i Bash, beroende på användningsfallet, kan du lagra heltal och strängar i samma array.

I den här handledningen kommer du att lära dig hur du deklarerar en Bash-array och kommer åt dess element. Du kommer sedan att lära dig hur du går igenom elementen i en array och lägger till element i en array. Slutligen kommer du att lära dig om associativa arrayer i Bash.

Låt oss börja!

⚙ Intresserad av att koda med? Här är förutsättningarna:

Hur man deklarerar en Bash Array

I det här avsnittet kommer du att lära dig syntaxen för att deklarera en Bash-array och kodexempel.

Syntax för Bash Array-deklaration

Du kan deklarera en array i Bash med följande syntax:

$ arrayName=(elt1 elt2 ... eltN)

# arrayName is the name of the array
# elt1 through eltN are the N elements in the array

I ovanstående syntax anger arrayName namnet på arrayen som innehåller N element elt1…eltN.

Elementen i en array är inneslutna mellan öppnings- och stängningsparentesen (). Observera också att elementen i arrayen är åtskilda av ett blanksteg. Som med alla Bash-variabler bör det inte finnas något blanksteg före eller efter tilldelningsoperatorn =.

📑 I de flesta andra programmeringsspråk kommer du att separera elementen i en array eller liknande samlingar med kommatecken. Men i Bash är blanksteg avgränsaren.

I Bash kallas sådana arrayer där elementen identifieras av deras index som indexerad array.

Deklarera indexerade arrayer i Bash

Låt oss skapa priser, en rad siffror.

$ prices=(24 27 18 30 15)

Som nämnts i syntaxen är siffrorna i prismatrisen åtskilda av ett blanksteg, omgivet av parentes, utan mellanslag före och efter tilldelningsoperatorn =.

  Hur du exporterar eller tar bort din Outlook.com-sökhistorik

I Bash kan du använda kommandot echo för att skriva ut värdet på en variabel. Genom att använda $variableName skrivs värdet av variableName ut. Du kan dock se att genom att använda namnet på arrayen skrivs endast det första elementet ut.

$ echo $prices
24

Bash-arrayer följer nollindexering. Så det första elementet är vid index 0, det andra elementet är vid index 1, och så vidare. Du kan också använda negativ indexering; indexet för det sista arrayelementet är -1.

Vad händer om du försöker komma åt elementet på ett visst index och skriva ut det? Låt oss försöka skriva ut elementet vid index 1.

$ echo $prices[1]
24[1]

Varför är utgången 24[1]? 🤔 Detta beror på att Bash ersätter $priser med 24, det första elementet i arrayen och [1] skrivs ut som sådan.

För att skriva ut elementet vid ett visst index kan du använda parameterexpansionen i formen ${prices[index]}.

$ echo ${prices[1]}
# 27
$ echo ${prices[2]}
# 18

För att skriva ut alla element i arrayen kan du ange @ istället för ett specifikt index.

$ echo ${prices[@]}
24 27 18 30 15

Låt oss sedan skapa en rad strängar. Genom att köra följande kommando skapas en indexerad array:

$ declare -a fruits

Alternativet -a skapar en indexerad array. Du kan nu fylla i arrayen, ett element i taget, genom att deklarera elementet vid ett specifikt index, som visas nedan:

$ fruits[0]="cherry"
$ fruits[1]="berry"
$ fruits[2]="apple"
$ fruits[3]="pear"
$ fruits[4]="melon"
$ fruits[5]="orange"

Nu, för att skriva ut alla element i arrayen, kan du använda ${fruits[@]}.

$ echo ${fruits[@]}
cherry berry apple pear melon orange

Få tillgång till Elements of a Bash Array

Du kan komma åt elementen i arrayen på följande sätt:

  • Gå igenom arrayen och få tillgång till elementet direkt
  • Gå igenom uppsättningen av index och åtkomstelement vid ett specifikt index

Slinga genom Array och Access Elements

Om du har kodat i Python har du använt for-loopen med följande syntax:

for elt in some_list:
    print(elt)

Låt oss nu skriva Bash-motsvarigheten till ovanstående för loop.

Vi vet att {priser[@]} expanderar till alla element i prismatrisen. Och ${priser[@]} ger oss värdena för alla element.

Bash for loop liknar Pythons för loop-syntax, men satserna i loop-kroppen bör omges av do and done, som visas:

$ for price in ${prices[@]}
> do
> echo $price
> done

Eftersom vi använder kommandot echo och skriver ut värdet på det rörliga priset får vi följande utdata:

# output
24
27
18
30
15

Få åtkomst till elementen med hjälp av Array Index

Ett annat sätt att gå igenom arrayer är att använda elementens index. Detta liknar for loop-konstruktionen i Python använder funktionen range():

for i in range(len(some_list)):
    print(i)

För att få en lista över index att gå igenom kan du placera ett utropstecken (!) före arraynamnet i parameterexpansionen. Detta ger dig en lista över alla giltiga index för arrayen, som visas:

$ echo ${!prices[@]}
0 1 2 3 4

Prismatrisen innehåller 5 element, så indexet börjar på 0 och går upp till 4.

  Här är vad du behöver veta

Därefter kan vi gå igenom listan med index och komma åt elementet vid varje index. För index i, ${prices[i]} är elementet vid index i.

$ for i in ${!prices[@]}
> do
> echo ${prices[i]}
> done

Ovanstående loop skriver ut alla element i arrayen.

# output
24
27
18
30
15

💬 Här, efter att ha kommit åt varje element, utför vi en enkel operation för att skriva ut dess värde. I allmänhet kan vi ha vilken giltig bearbetning som helst av elementen.

Lägg till element till en bash-array

I prismatrisen 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 på följande sätt:

$ prices[5]=21

Vi ser att 21 har lagts till i slutet av prismatrisen.

$ echo ${prices[@]}
24 27 18 30 15 21

Det är dock bekvämare att lägga till indexet för det senast tillagda elementet eller antalet element som för närvarande finns i arrayen i slutet av arrayen – utan att komma ihåg.

Du kan använda arrayName+=(element(s)) för att lägga till ett eller flera element till en array, som visas:

$ prices+=(10)

Om vi ​​nu skriver ut prismatrisen ser vi att 10 har lagts till i slutet av matrisen.

$ echo ${prices[@]}
24 27 18 30 15 21 10

Låt oss sedan lära oss hur man deklarerar associativa arrayer i Bash.

Associativa arrayer i Bash

Om du vill definiera en relation i termer av nyckel-värdepar kan du använda en associativ array. Du kan deklarera en associativ array med följande allmänna syntax. Lägg märke till att vi använder alternativet -A istället för -a.

$ declare -A fruits_prices

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 siffrorna från prismatrisen som värden.

$ fruits_prices[cherry]=24
$ fruits_prices[berry]=27
$ fruits_prices[apple]=18
$ fruits_prices[pear]=30
$ fruits_prices[melon]=15
$ fruits_prices[orange]=21

Så hur kommer vi åt elementen i en associativ array?

  Hur man konverterar PNG-, TIFF- och JPEG-bilder till ett annat format på din Mac

Precis som du skulle slå upp värdet med motsvarande nyckel i en Python-ordbok, kan du komma åt värdena i en associativ array med hjälp av nycklarna.

$ echo ${fruits_prices[berry]}
# 27

Vi ser att ${fruits_prices[@]} expanderar till värdena och ${!fruits_prices[@]} expanderar till tangenterna.

$ echo ${fruits_prices[@]}
# Output: 18 27 21 24 30 15
$ echo ${!fruits_prices[@]}
# Output: apple berry orange cherry pear melon

Obs: Ordningen på elementen är inte densamma som den ordning vi la till dem i. Detta beror på att, till skillnad från indexerade arrayer, är associativa arrayer inte ordnade samlingar. Snarare arbetar de med sambandet mellan nycklarna och värderingarna. Därför är nycklar till associativa arrayer vad index är för indexarrayer.

Du kan också gå igenom den associativa arrayen och komma åt nycklarna, som visas:

$ for key in ${!fruits_prices[@]}
> do
> echo $key
> done
# Output
apple
berry
orange
cherry
pear
melon

Följande loop visar hur du kan komma åt värdena.

$ for value in ${fruits_prices[@]}
> do
> echo $value
> done
# Output
18
27
21
24
30
15

Även om det rekommenderas att använda arrayName[key]=värde, du kan också deklarera det som en sekvens så här:

declare -A arrayName
arrayName=(key1 value1 key2 value2 ... keyN valueN)

På så sätt 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.

Summering

Jag hoppas att du nu förstår hur man skapar och arbetar med Bash-arrayer. Här är en snabb genomgång av vad du har lärt dig.

  • Du kan deklarera en indexerad array i Bash med hjälp av syntaxen arrayName=(elt1 elt2 elt3 … eltN) eller köra declare -a arrayName och lägga till element till arrayen.
  • För att komma åt elementen kan du gå igenom med ${arrayName[@]}. Alternativt kan du få listan över alla giltiga index med hjälp av parameterexpansionen ${!arrayName[@]}.
  • Slutligen lärde du dig också hur man deklarerar en associativ array för att lagra nyckel-värdepar i Bash.

Kolla sedan in handledningen för loopar i Bash.