Hoe arrays in bash-script te gebruiken

  • Matthew Stevenson
  • 0
  • 1446
  • 334
> Bash, de Bourne Again Shell, het is de standaard shell op praktisch alle grote Linux-distributies: het is echt krachtig en kan ook worden beschouwd als een programmeertaal, hoewel niet zo geavanceerd of feature-bereik als Python of andere "juiste" talen. Bovendien is de Bash-scripting een vereiste vaardigheid voor elke Linux-systeembeheertaak. In deze tutorial zullen we zien hoe we bash-arrays kunnen gebruiken en er fundamentele bewerkingen op kunnen uitvoeren.
Na het volgen van deze tutorial zou je moeten kunnen begrijpen hoe bash-arrays werken en hoe je de basisbewerkingen erop kunt uitvoeren.

Maak een array

Het eerste dat u moet doen, is onderscheid maken tussen bash geïndexeerd array en bash associatief array. De eerste zijn arrays waarin de sleutels geordende gehele getallen zijn, terwijl de laatste arrays zijn waarin de sleutels worden weergegeven door strings. Hoewel geïndexeerde arrays op veel manieren kunnen worden geïnitialiseerd, kunnen associatieve arrays alleen worden gemaakt door de verklaren commando zoals we zo dadelijk zullen zien.

Maak geïndexeerde of associatieve arrays met behulp van declareren

We kunnen expliciet een array maken door de verklaren opdracht:
$ declareer -een my_array
Verklaar, in bash, dat het wordt gebruikt om variabelen en attributen in te stellen. In dit geval, aangezien we de -een optie, een geïndexeerde array is gemaakt met de naam "my_array".
Associatieve arrays kunnen op dezelfde manier worden gemaakt: het enige dat we moeten wijzigen, is de gebruikte optie: in plaats van kleine letters -een we moeten de -EEN optie van de verklaren opdracht:
$ declare -A my_array
Dit is, zoals gezegd, de enige manier om associatieve arrays in bash te maken.

Maak direct geïndexeerde arrays

We kunnen geïndexeerde arrays maken met een beknoptere syntaxis, door ze simpelweg enkele waarden toe te wijzen:
$ my_array = (foo-balk)
In dit geval hebben we meerdere items tegelijk aan de array toegewezen, maar we kunnen ook één waarde per keer invoegen, waarbij we de index specificeren:
$ my_array [0] = foo

Matrixbewerkingen

Zodra een array is gemaakt, kunnen we er enkele nuttige bewerkingen op uitvoeren, zoals het weergeven van de sleutels en waarden of het wijzigen door elementen toe te voegen of te verwijderen:

Druk de waarden van een array af

Om alle waarden van een array weer te geven, kunnen we de volgende shell-uitbreidingssyntaxis gebruiken:
$ echo $ my_array [@]
Of zelfs:
$ echo $ my_array [*]
Beide syntaxis geven ons toegang tot alle waarden van de array en produceren dezelfde resultaten, tenzij de uitbreiding wordt geciteerd. In dit geval ontstaat er een verschil: in het eerste geval bij gebruik @, de uitbreiding resulteert in een woord voor elk element van de array. Dit wordt direct duidelijk bij het uitvoeren van een for loop. Stel je bijvoorbeeld voor dat we een array hebben met twee elementen, "foo" en "bar":
$ my_array = (foo-balk)
Een voor loop erop zal het volgende resultaat opleveren:
 $ voor i in "$ my_array [@]"; echo "$ i"; gedaan foo bar 
Tijdens gebruik *, en de variabele wordt geciteerd, in plaats daarvan wordt een enkel "resultaat" geproduceerd, dat alle elementen van de array bevat:
 $ voor i in "$ my_array [*]"; echo "$ i"; gedaan foo bar 


Druk de sleutels van een array af

Het is zelfs mogelijk om de sleutels die worden gebruikt in een geïndexeerde of associatieve array op te halen en af ​​te drukken, in plaats van hun respectieve waarden. De syntaxis is bijna identiek, maar is afhankelijk van het gebruik van de ! operator:
 $ my_array = (foo bar baz) $ voor index in "$ ! my_array [@]"; echo "$ index"; gedaan 0 1 2 
Hetzelfde geldt voor associatieve arrays:
 $ declare -A my_array $ my_array = ([foo] = bar [baz] = foobar) $ voor sleutel in "$ ! my_array [@]"; echo "$ key"; gedaan baz foo 
Zoals u kunt zien, aangezien de laatste een associatieve array is, kunnen we er niet op rekenen dat opgehaalde waarden worden geretourneerd in dezelfde volgorde waarin ze zijn gedeclareerd.

De grootte van een array krijgen

We kunnen de grootte van een array (het aantal elementen erin) achterhalen door een specifieke shell-uitbreiding te gebruiken:
 $ my_array = (foo bar baz) $ echo "de array bevat $ # my_array [@] elementen" de array bevat 3 elementen 
We hebben een array gemaakt die drie elementen bevat, "foo", "bar" en "baz", en vervolgens door de syntaxis hierboven te gebruiken, die verschilt van degene die we eerder zagen om de arraywaarden alleen op te halen voor de # teken vóór de arraynaam, hebben we het aantal elementen in de array opgehaald in plaats van de inhoud ervan.

Elementen aan een array toevoegen

Zoals we hebben gezien, kunnen we elementen aan een geïndexeerde of associatieve array toevoegen door respectievelijk hun index of associatieve sleutel op te geven. In het geval van geïndexeerde arrays kunnen we ook eenvoudig een element toevoegen door aan het einde van de array toe te voegen met de += operator:
 $ my_array = (foo bar) $ my_array + = (baz) 
Als we nu de inhoud van de array printen, zien we dat het element succesvol is toegevoegd:
 $ echo "$ my_array [@]" foo bar baz 
Er kunnen meerdere elementen tegelijk worden toegevoegd:
 $ my_array = (foo bar) $ my_array + = (baz foobar) $ echo "$ my_array [@]" foo bar baz foobar 
Om elementen aan een associatieve array toe te voegen, moeten we ook de bijbehorende sleutels specificeren:
$ declare -A my_array # Eén element toevoegen $ my_array [foo] = "bar" # Meerdere elementen tegelijk toevoegen $ my_array + = ([baz] = foobar [foobarbaz] = baz) 


Een element uit de array verwijderen

Om een ​​element uit de array te verwijderen, moeten we de index kennen of de sleutel in het geval van een associatieve array, en de uitgeschakeld opdracht. Laten we een voorbeeld bekijken:
 $ my_array = (foo bar baz) $ unset my_array [1] $ echo $ my_array [@] foo baz 
We hebben een eenvoudige array gemaakt met drie elementen, "foo", "bar" en "baz", en vervolgens hebben we "bar" verwijderd. uitgeschakeld en verwijzen naar de index van "bar" in de array: in dit geval weten we dat het was 1, aangezien bash-arrays beginnen bij 0. Als we de indexen van de array controleren, kunnen we dat nu zien 1 ontbreekt:
 $ echo $ ! my_array [@] 0 2 
Hetzelfde geldt voor associatieve arrays:
 $ declare -A my_array $ my_array + = ([foo] = bar [baz] = foobar) $ unset my_array [foo] $ echo $ my_array [@] foobar 
In het bovenstaande voorbeeld is de waarde waarnaar wordt verwezen door de "foo" -toets verwijderd, waardoor alleen "foobar" in de array overblijft.
Het verwijderen van een hele array is nog eenvoudiger: we geven de arraynaam gewoon als argument door aan de uitgeschakeld commando zonder een index of sleutel op te geven:
 $ unset my_array $ echo $ ! my_array [@] 
Na het uitvoeren uitgeschakeld tegen de hele array, wanneer wordt geprobeerd de inhoud af te drukken, wordt een leeg resultaat geretourneerd: de array bestaat niet meer.

Conclusies

In deze tutorial zagen we het verschil tussen geïndexeerde en associatieve arrays in bash, hoe ze te initialiseren en hoe fundamentele bewerkingen moesten worden uitgevoerd, zoals het weergeven van hun sleutels en waarden en het toevoegen of verwijderen van items. Eindelijk zagen we hoe we ze volledig konden uitschakelen. Bash-syntaxis kan soms behoorlijk raar zijn, maar het gebruik van arrays in scripts kan erg handig zijn. Wanneer een script complexer begint te worden dan verwacht, is mijn advies echter om over te schakelen naar een meer capabele scripttaal zoals python.



Niemand heeft nog op dit artikel gereageerd.

Een verzameling nuttige informatie over het Linux-besturingssysteem en nieuwe technologieën
Nieuwe artikelen, praktische tips, gedetailleerde recensies en handleidingen. Voel je thuis in de wereld van het Linux-besturingssysteem