Bash-woordenboeken geven je hash-kaarten en associatieve arrays in Linux-shellscripts. We laten u zien hoe u deze krachtige en nuttige gegevensstructuren kunt gebruiken in uw eigen Linux-shellscripts.
A Rose by Any Other Naam
GERELATEERDWat is de Bash Shell en waarom is het zo belangrijk voor Linux? De formele naam voor woordenboeken is associatieve arrays. Ze worden ook hash-tabellen en hash-kaarten genoemd. Het is een gegevensstructuur die op dezelfde manier werkt als een gewone array, maar met een significant verschil.
Een array is een verzameling gegevenswaarden die in één gegevensstructuur worden bewaard. Om toegang te krijgen tot een van de gegevenswaarden, die array-elementen worden genoemd, moet u hun positie in de array weten. De positie van een array-element in de array staat bekend als de index, dus dit soort arrays staan bekend als geïndexeerde arrays. Ze zijn het meest gebruikte type arrays.
Ze hebben echter een nadeel. Hoe krijg je toegang tot een array-element als je zijn positie in de lijst niet weet? Je moet alle elementen in de array doorlopen en testen of de waarde op die locatie degene is die je zoekt.
Associatieve arrays verhelpen dat probleem. Ze gebruiken geen gehele getallen om array-elementen uniek te identificeren. Ze gebruiken unieke woorden die trefwoorden worden genoemd. U kunt de waarde voor een array-element ophalen door het trefwoord te gebruiken, ongeacht waar het binnen de array is geplaatst. Bij een geïndexeerde array staan de gehele getallen die de posities binnen de array vertegenwoordigen in oplopende volgorde. De trefwoorden in een associatieve array kunnen in elke volgorde staan.
U kunt een waarde opzoeken in een associatieve array door te zoeken met het bijbehorende trefwoord. Het opzoeken van een woord en het ophalen van de bijbehorende waarde bootst het opzoeken van een woord in een woordenboek na en het vinden van de betekenis ervan. Daarom staan associatieve arrays bekend als woordenboeken.
Bash 4.0 of hoger
Associatieve arrays worden ondersteund in de Bash-shell versie 4.0 of hoger. Als je een huidige Linux-distributie gebruikt, zou het goed moeten komen. Gebruik deze opdracht om uw Bash-versie te controleren:
bash –version
Advertentie
De machine die is gebruikt om dit artikel te onderzoeken, heeft Bash 5.1.4 geïnstalleerd, dus we zijn klaar om te gaan.
Basisprincipes
Om een associatieve array op de opdrachtregel van de terminal of in een script, gebruiken we de opdracht Bash declare. De -A (associatieve) optie vertelt Bash dat dit een associatieve array zal zijn en niet een geïndexeerde array.
declare -A acroniemen
Dit creëert een associatieve array genaamd “acroniemen.
Om wat gegevens in onze array te plaatsen, moeten we trefwoorden en waarden opgeven. We kunnen dit doen met dit formaat:
array-name[key]=Waarde
Laten we enkele array-elementen toevoegen:
acroniemen[ACK]=Acknowledgement acroniemen[BGP]=”Border Gateway Protocol” acroniemen[CIDR]=”Classless Inter-Domain Routing” acroniemen[DHCP]=”Dynamic Host Configuration Protocol” acroniemen[EOF]=”End of Frame”
Die commando's definiëren vijf array-elementen. Merk op dat de waarden tussen aanhalingstekens staan als er spaties in de waarde staan. Onze trefwoorden zijn in alfabetische volgorde ingevoerd, maar ze kunnen in elke gewenste volgorde worden ingevoerd. De zoekwoorden moeten uniek zijn. Als u twee vermeldingen met hetzelfde trefwoord probeert te maken, overschrijft de tweede waarde die u invoert de eerste. U heeft nog steeds maar één item met dat trefwoord en het wordt gekoppeld aan de tweede waarde die u heeft toegevoegd.
Om waarden uit de array op te halen, gebruiken we commando's in dit formaat:
${array-name[key]} Advertisement
We kunnen echo gebruiken om de uitvoer naar het terminalvenster te sturen:
echo ${acroniemen[ACK]} echo ${acroniemen[DHCP]}
< h2 role="heading" aria-level="2">Lussen gebruiken
Arrays lenen zich uitstekend om in loops te worden gebruikt. Associatieve arrays zijn geen uitzondering. Loops bieden efficiënte manieren om een reeks acties op te roepen zonder repetitieve codesecties. Voordat we naar lussen kijken, is er een efficiënte manier om arrays te declareren.
We maken de arrays met het declare-commando (dezelfde -A-optie als voorheen), maar we geven de trefwoorden en waarden op als een lijst op de opdrachtregel.
declare -A countries=( [ALB]=Albanië [BHR]=Bahrein [CMR]=Kameroen [DNK]=Denemarken [EGY]=Egypte )
De arraynaam is “landen,” en het is verbonden met de lijst met waarden door een isgelijkteken ” =.” De lijst met waarden staat tussen haakjes “()” en elk trefwoord staat tussen haakjes “[]“. Merk op dat er geen komma's tussen de waarden staan. Als u een waardetekenreeks heeft die spaties bevat, moet u deze tussen aanhalingstekens plaatsen.
Om een associatieve array een sleutelwoord te laten retourneren in plaats van de waarde, voegt u een uitroepteken toe “!” voor de arraynaam. Het at-symbool “@” kan worden gebruikt als een jokerteken, wat betekent dat alle array-elementen worden gebruikt.
Deze for-lus geeft alle trefwoorden weer:
for key in “${!countries[@]}”; doe echo $key; done
Merk op dat de trefwoorden niet noodzakelijk in de volgorde worden vermeld dat ze zijn gemaakt, maar dat doet er niet toe. Associatieve arrays zijn niet afhankelijk van een geordende index.
Advertentie
We kunnen ook parameteruitbreiding gebruiken om alle trefwoorden op te sommen. Ze worden op één regel vermeld, niet één per regel.
echo “${!countries[@]}” echo “${!acroniemen[@]}”
We kunnen onze for-lus uitbreiden om de trefwoorden en waarden tegelijkertijd af te drukken.
for key in “${!acroniemen[@]}”; do echo “$key – ${acroniemen[$key]}”; klaar
Als we willen weten hoeveel elementen er in de arrays zitten, kunnen we een hash gebruiken “#” voor de arraynaam in plaats van een uitroepteken.
echo “${!countries[@]}” echo “${!acroniemen[@]}”
Controleren of een array-element bestaat
Als u zoek naar een trefwoord maar er is niet zo'n array-element, de geretourneerde waarde is een lege tekenreeks. Soms is het handig om een andere indicator te hebben voor de aan- of afwezigheid van een array-element.
We kunnen de aanwezigheid van een array-element controleren met behulp van de “+_” exploitant. Merk op dat dit na het sleutelwoord komt, niet voor de arraynaam zoals de vorige operatoren die we hebben gezien.
if [ ${acronyms[EOF]+_} ]; echo dan “Gevonden”; else echo “Niet gevonden”; fi if [ ${acroniemen[FTP]+_} ]; echo dan “Gevonden”; else echo “Niet gevonden”; fi
Het array-element met het trefwoord “EOF” wordt gevonden in de array, maar het array-element met het trefwoord “FTP” is dat niet.
Array-elementen toevoegen
Nieuwe elementen toevoegen aan een associatieve array is eenvoudig. In tegenstelling tot sommige programmeertalen, hoeft u de grootte van uw array niet te definiëren wanneer u deze declareert. U kunt nieuwe elementen blijven toevoegen zonder een vooraf gedefinieerde bovengrens te bereiken.
Advertentie
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 zoeken naar het nieuwe sleutelwoord vindt het array-element en geeft de waarde terug.
Array-elementen en arrays verwijderen
De opdracht unset wordt gebruikt om array-elementen te verwijderen. Als het trefwoord spaties bevat, plaatst u het tussen aanhalingstekens.
acroniemen uitschakelen [EOF] als [ ${acroniemen[EOF]+_} ]; echo dan “Gevonden”; else echo “Niet gevonden”; fi
Om de hele array te verwijderen, gebruik je unset met de naam van de array .
uitgeschakelde landen
Variabelen gebruiken met arrays
Het gebruik van variabelen met associatieve arrays is eenvoudig. In dit voorbeeld stellen we een variabele sleutel in op de tekenreeks “EOF.” We gebruiken de variabele wanneer we een nieuw array-element aan de array toevoegen. Eigenlijk vervangen we het array-element dat we eerder hebben verwijderd.
We halen het nieuwe array-element op door het aan te roepen met het nieuwe sleutelwoord en ook door de variabele te gebruiken. Als het trefwoord spaties bevat, moet u de naam van de variabele tussen aanhalingstekens plaatsen.
key=EOF acroniemen[$key]=”End of Frame” echo ${acronyms[EOF]} echo ${ acroniemen[$key]}
Wees creatief
Onze voorbeelden zijn verzamelingen van informatie waarbij elk array-element onafhankelijk is van alle andere, net als een woordenboek. Elk is een unieke definitie. Maar associatieve arrays kunnen net zo goed verschillende stukjes informatie bevatten die allemaal met één ding te maken hebben, zoals de specificaties van verschillende stukjes computerhardware:
declare -A specificatie specificatie[CPU]=”Dual Core AMD Ryzen 5 3600″ specificatie[Speed]=”3600 MHz” specificatie[Kernel]=”5.11.0-17-generic x86_64″ specificatie[Mem]=”1978.5 MiB” specificatie[Storage]=”32 GiB” specificatie[Shell]=”Bash” echo ${specificatie[CPU]}
Efficiënt schrijven in een taal betekent de mechanismen en structuren kennen die het biedt, en de meest geschikte kiezen voor het probleem dat je probeert op te lossen. Associatieve arrays bieden u een gebruiksvriendelijke manier om gegevens op te slaan die u op naam kunt zoeken, net als in een woordenboek.
LEES VOLGENDE
- › Android's 'Material You' Thema's zijn geweldig, maar verwacht niet dat Samsung het gaat gebruiken
- › Een tijdelijke weergave maken bij samenwerking in Excel
- › De .NET Framework-versie controleren op Windows 10
- › Wat is kleurdiepte?
- › Hoe u al uw Smart Home-apparaten in één app kunt bedienen