Wat zijn Bash Woordenboeken op Linux, en hoe worden ze gebruikt?

Bash-woordenboeken geven u Hash-kaarten en associatieve arrays in Linux Shell-scripts. We zullen u laten zien hoe u deze krachtige en nuttige gegevensstructuren in uw eigen Linux Shell-scripts kunt gebruiken.

Een roos door een andere naam

Een array is een verzameling gegevenswaarden die in één gegevensstructuur worden gehouden. Om toegang te krijgen tot een van de gegevenswaarden, die bekend staan ​​als array-elementen, moet u hun positie in de array kennen. De positie van een arrayelement in de array staat bekend als zijn index, dus deze soorten arrays staan ​​bekend als geïndexeerde arrays. Ze zijn het meest gebruikte type arrays.

Ze hebben echter een nadeel. Hoe voert u toegang tot een arrayelement als u zijn positie niet in de lijst kent? U moet alle elementen in de array doorlopen, testen om te zien of de waarde op die locatie degene is die u zoekt.

Associatieve arrays overwinnen dat probleem. Ze gebruiken geen gehele getallen om array-elementen uniek te identificeren. Ze gebruiken unieke woorden die bekend staan ​​als zoekwoorden. U kunt de waarde voor een array-element ophalen met behulp van het zoekwoord, ongeacht waar het in de array is geplaatst. Met een geïndexeerde array zijn de getallennummers die de posities binnen de array vertegenwoordigen in oplopende volgorde. De zoekwoorden in een associatieve array kunnen in willekeurige volgorde zijn.

U kunt een waarde opzoeken in een associatieve array door op zoek te gaan naar het zoekwoord. Opzoeken van een woord en het ophalen van zijn bijbehorende waarde Mimics opzoeken op zoek naar een woord in een woordenboek en het vinden van de betekenis ervan. Dat is waarom associatieve arrays bekend staan ​​als woordenboeken.

Bash 4.0 of hoger

Associatieve arrays worden ondersteund in The Bash Shell versie 4.0 of hoger. Als u een huidige Linux-distributie gebruikt, zou u in orde moeten zijn. Gebruik deze opdracht om uw bash-versie te controleren:

 BASH --VERSIE 

De machine die wordt gebruikt om dit artikel te onderzoeken heeft bash 5.1.4 geïnstalleerd, dus we zijn goed om te gaan.

Basisprincipes

Om een ​​associatieve array op de opdrachtregel van de terminal of in een script te maken, gebruiken we de opdracht bash. De -EEN (associatieve) optie vertelt bash dat dit een associatieve array zal zijn en geen geïndexeerde array.

 Declare -A AcroniMs 

Dit creëert een associatieve array die "acroniemen" wordt genoemd.

Om sommige gegevens in onze array te plaatsen, moeten we zoekwoorden en waarden verstrekken. We kunnen dit doen met dit formaat:

 Array-Name [sleutel] = waarde 

Laten we een aantal array-elementen toevoegen:

 Acronyms [ACK] = bevestiging 

 Acroniemen [BGP] = "Border Gateway-protocol" 

 Acroniemen [CIDR] = "Klassoze inter-domein routing" 

 Acronyms [DHCP] = "Dynamic Host Configuration Protocol" 

 Acroniemen [EOF] = "Einde van het frame" 

Die commando's definiëren vijf array-elementen. Merk op dat de waarden zijn ingepakt in aanhalingstekens als er spaties in de waarde zijn. Onze zoekwoorden zijn ingevoerd in alfabetische volgorde, maar ze kunnen in elke volgorde worden ingevoerd die u leuk vindt. De zoekwoorden moeten uniek zijn. Als u probeert twee vermeldingen met hetzelfde zoekwoord te maken, overschrijft de tweede waarde die u invoert de eerste. U hebt nog maar één toegang met dat trefwoord, en het zal worden geassocieerd met de tweede waarde die u hebt toegevoegd.

Om waarden uit de array op te halen, gebruiken we opdrachten in dit formaat:

 $ {array-name [sleutel]} 

We kunnen ECHO gebruiken om de uitvoer naar het venster Terminal te verzenden:

 ECHO $ ​​{acronyms [ACK]} 

 echo $ {acronyms [DHCP]} 

Loops gebruiken

Arrays lenen zich ervoor dat ze heel goed in lussen worden gebruikt. Associatieve arrays zijn geen uitzondering. Loops bieden efficiënte manieren om een ​​reeks acties aan te roepen zonder repetitieve secties van de code. Voordat we naar lussen kijken, is er een efficiënte manier om arrays te declareren.

We maken de arrays met behulp van de verklaren commando (hetzelfde -EEN Optie als voorheen), maar wij bieden de zoekwoorden en waarden als een lijst op de opdrachtregel.

 Declare -A-A-landen = ([ALB] = ALBANIA [BHR] = BAHRAIN [CMR] = Kameroen [DNK] = DENEMARKEN [EGY] = EGYPTE) 

De arraynaam is "landen" en het is verbonden met de waardelijst door een gelijkteken " = . " De waardelijst is gewikkeld tussen haakjes " () "En elk zoekwoord is gewikkeld tussen haakjes" [] ". Merk op dat er geen komma's zijn die de waarden scheiden. Als u een waardestring hebt die spaties bevat, moet u deze in aanhalingstekens inpakken.

Om een ​​associatieve array te maken, retourneert u een sleutelwoord in plaats van de waarde, voeg een uitroepteken toe " ! "Voor de arraynaam. Het bij symbool " @ "Kan worden gebruikt als een jokerteken, wat betekent dat alle array-elementen zijn.

Dit voor Loop vermeldt al de trefwoorden:

 Voor de sleutel in "$ {! Landen [@]}"; do ECHO $-sleutel; gedaan 

Merk op dat de zoekwoorden niet noodzakelijk worden vermeld in de volgorde waarin ze zijn gemaakt, maar dat maakt niet uit. Associatieve arrays vertrouwen niet op een bestelde index.

We kunnen ook parameteruitbreiding gebruiken om al de trefwoorden te vermelden. Ze worden op één regel vermeld, niet één per regel.

 Echo "$ {! Landen [@]}" 

 echo "$ {! Acronyms [@]}" 

We kunnen ons vergroten voor Loop om de trefwoorden en waarden tegelijkertijd af te drukken.

 Voor de sleutel in "$ {! Acroniemen [@]}"; DO ECHO "$ KEY - $ {ACRONIMS [$ KEY]}"; gedaan 

Als we willen weten hoeveel elementen er in de arrays zijn, kunnen we een hash "#" voor de arraynaam gebruiken in plaats van een uitroepteken.

 Echo "$ {! Landen [@]}" 

 echo "$ {! Acronyms [@]}" 

Controleren dat een arrayelement bestaat

Als u zoekt naar een trefwoord, maar er is geen dergelijk arrayelement, de retourwaarde is een lege tekenreeks. Soms is het nuttig om een ​​andere indicator te hebben voor de aanwezigheid of afwezigheid van een arrayelement.

We kunnen controleren op de aanwezigheid van een arrayelement met behulp van de " + _ "Operator. Merk op dat dit na het sleutelwoord komt, niet voor de arraynaam zoals de vorige operators die we hebben gezien.

 Indien [$ {acroniemen [EOF] + _}]; dan echo "gevonden"; anders echo "niet gevonden"; fi 

 Indien [$ {acroniemen [FTP] + _}]; dan echo "gevonden"; anders echo "niet gevonden"; fi 

Het arrayelement met het trefwoord "EOF" is te vinden in de array, maar het array-element met het trefwoord "FTP" is dat niet.

ARRAY-elementen toevoegen

Het toevoegen van nieuwe elementen aan een associatieve array is eenvoudig. In tegenstelling tot sommige programmeertalen hoeft u niet de grootte van uw array te definiëren wanneer u het declareert. U kunt blijven toevoegen aan nieuwe elementen zonder een vooraf gedefinieerde bovengrens te treffen.

Om een ​​nieuw element aan de array toe te voegen, gebruiken we de " + = "Operator.

 Landen + = ([FJI] = FIJI) 

 Echo "$ (# Landen [@]}" 

 ECHO $ ​​{LANDEN [FJI]} 

Het aantal elementen in de array is nu zes, en het zoeken naar het nieuwe sleutelwoord vindt het array-element en retourneert zijn waarde.

Array-elementen en arrays verwijderen

De ongezond opdracht wordt gebruikt om array-elementen te verwijderen. Als het sleutelwoord er spaties in heeft, wikkelt u deze in aanhalingstekens.

 Ongesproken acroniemen [EOF] 

 Indien [$ {acroniemen [EOF] + _}]; dan echo "gevonden"; anders echo "niet gevonden"; fi 

Om de hele array te verwijderen, gebruikt u ongezond met de naam van de array.

 Onderdelen 

Variabelen met arrays gebruiken

Het gebruik van variabelen met associatieve arrays is eenvoudig. In dit voorbeeld stellen we een variabele sleutel in op het string "EOF." We gebruiken de variabele wanneer we een nieuw arrayelement toevoegen aan de array. Eigenlijk vervangen we het arrayelement dat we eerder verwijderden.

We halen het nieuwe array-element op door het met het nieuwe sleutelwoord te bellen en ook door de variabele te gebruiken. Als het sleutelwoord spaties bevat, moet u de variabele naam in aanhalingstekens inpakken.

 Sleutel = EOF 

 Acroniemen [$ KEY] = "EINDE VAN FRAME" 

 echo $ {acronyms [EOF]} 

 echo $ {acronyms [$ sleutel]} 

Wees creatief

Onze voorbeelden zijn verzamelingen van informatie waarbij elk arrayelement onafhankelijk is van alle anderen, net als een woordenboek. Iedereen is een unieke definitie. Maar associatieve arrays kunnen net zo gemakkelijk een verscheidenheid aan informatie bevatten die allemaal verband houden met één ding, zoals de specificaties van verschillende stukken computerhardware:

 Declare -A -A-specificatie 

 Specificatie [CPU] = "Dual Core AMD RYZEN 5 3600" 

 Specificatie [Snelheid] = "3600 MHz" 

 Specificatie [kernel] = "5.11.0-17-generieke X86_64" 

 Specificatie [MEM] = "1978.5 MIB" 

 Specificatie [opslag] = "32 GIB" 

 Specificatie [Shell] = "Bash" 

 echo $ {specificatie [CPU]} 

Het schrijven van efficiënt in een taal betekent kenmerken van de mechanismen en structuren die het biedt en het meest geschikte te selecteren voor het probleem dat u probeert op te lossen. Associatieve arrays geven u een eenvoudig te gebruiken manier om gegevens op te slaan die u op naam kunt zoeken, net als een woordenboek.