Zoeken op website

Werken met arrays in Linux Shell Scripting – Deel 8

We kunnen ons geen programmeertaal voorstellen zonder het concept van arrays. Het maakt niet uit hoe ze in verschillende talen worden geïmplementeerd. In plaats daarvan helpen arrays ons bij het consolideren van gegevens, vergelijkbaar of verschillend, onder één symbolische naam.

Omdat we ons zorgen maken over shell-scripting, zal dit artikel je helpen bij het spelen met enkele shell-scripts die gebruik maken van dit concept van arrays.

Initialisatie en gebruik van arrays

Met nieuwere versies van bash ondersteunt het eendimensionale arrays. Een array kan expliciet worden gedeclareerd door de ingebouwde shell declare.


declare -a var

Maar het is niet nodig om arrayvariabelen te declareren zoals hierboven. We kunnen individuele elementen als volgt rechtstreeks in de array invoegen.


var[XX]=<value>

waarbij ‘XX’ de array-index aangeeft. Om array-elementen te derefereren, gebruikt u de syntaxis van de accolades, d.w.z.


${var[XX]}

Opmerking: Array-indexering begint altijd met 0.

Een andere handige manier om een hele array te initialiseren is door het paar haakjes te gebruiken, zoals hieronder weergegeven.


var=( element1 element2 element3 . . . elementN )

Er is nog een andere manier om waarden aan arrays toe te wijzen. Deze manier van initialiseren is een subcategorie van de eerder uitgelegde methode.


array=( [XX]=<value> [XX]=<value> . . . )

We kunnen tijdens de uitvoering ook waarden aan de array lezen/toewijzen met behulp van de ingebouwde shell read.


read -a array

Bij het uitvoeren van de bovenstaande instructie in een script wacht het op enige invoer. We moeten de array-elementen gescheiden door een spatie opgeven (en niet door een regelterugloop). Druk na het invoeren van de waarden op Enter om te beëindigen.

Om door de array-elementen te lopen, kunnen we ook een for-lus gebruiken.


for i in “${array[@]}”
do
	#access each element as $i. . .
done

Het volgende script vat de inhoud van deze specifieke sectie samen.


#!/bin/bash 

array1[0]=one 
array1[1]=1 
echo ${array1[0]} 
echo ${array1[1]} 

array2=( one two three ) 
echo ${array2[0]} 
echo ${array2[2]} 

array3=( [9]=nine [11]=11 ) 
echo ${array3[9]} 
echo ${array3[11]} 

read -a array4 
for i in "${array4[@]}" 
do 
	echo $i 
done 

exit 0

Verschillende bewerkingen op arrays

Veel van de standaard stringbewerkingen werken op arrays. Bekijk het volgende voorbeeldscript dat enkele bewerkingen op arrays implementeert (inclusief tekenreeksbewerkingen).


#!/bin/bash 

array=( apple bat cat dog elephant frog ) 

#print first element 
echo ${array[0]} 
echo ${array:0} 

#display all elements 
echo ${array[@]} 
echo ${array[@]:0} 

#display all elements except first one 
echo ${array[@]:1} 

#display elements in a range 
echo ${array[@]:1:4} 

#length of first element 
echo ${#array[0]} 
echo ${#array} 

#number of elements 
echo ${#array[*]} 
echo ${#array[@]} 

#replacing substring 
echo ${array[@]//a/A} 

exit 0

Hieronder volgt de uitvoer die wordt geproduceerd bij het uitvoeren van het bovenstaande script.


apple 
apple 
apple bat cat dog elephant frog 
apple bat cat dog elephant frog 
bat cat dog elephant frog 
bat cat dog elephant 
5 
5 
6 
6 
Apple bAt cAt dog elephAnt frog

Ik denk dat het geen betekenis heeft om het bovenstaande script in detail uit te leggen, aangezien het voor zichzelf spreekt. Indien nodig zal ik een deel in deze serie uitsluitend aan snaarmanipulaties wijden.

Commandovervanging met arrays

Commandovervanging wijst de uitvoer van een commando of meerdere commando's toe aan een andere context. Hier in deze context van arrays kunnen we de uitvoer van opdrachten invoegen als individuele elementen van arrays. De syntaxis is als volgt.


array=( $(command) )

Standaard wordt de inhoud in de uitvoer van de opdracht, gescheiden door spaties, als afzonderlijke elementen in de array geplaatst. Het volgende script geeft de inhoud van een map weer, dit zijn bestanden met 755-machtigingen.


#!/bin/bash 

ERR=27 
EXT=0 

if [ $# -ne 1 ]; then 
	echo "Usage: $0 <path>" 
	exit $ERR 
fi 

if [ ! -d $1 ]; then 
	echo "Directory $1 doesn't exists" 
	exit $ERR 
fi 

temp=( $(find $1 -maxdepth 1 -type f) ) 

for i in "${temp[@]}" 
do 
	perm=$(ls -l $i) 
	if [ `expr ${perm:0:10} : "-rwxr-xr-x"` -eq 10 ]; then 
		echo ${i##*/} 
	fi 
done 

exit $EXT

Simulatie van tweedimensionale arrays

We kunnen gemakkelijk een tweedimensionale matrix weergeven met behulp van een ééndimensionale array. In hoofdvolgorde worden representatie-elementen in elke rij van een matrix progressief op een sequentiële manier opgeslagen in array-indexen. Voor een mXn-matrix kan de formule hiervoor worden geschreven als.


matrix[i][j]=array[n*i+j]

Bekijk een ander voorbeeldscript voor het toevoegen van twee matrices en het afdrukken van de resulterende matrix.


#!/bin/bash 

read -p "Enter the matrix order [mxn] : " t 
m=${t:0:1} 
n=${t:2:1} 

echo "Enter the elements for first matrix" 
for i in `seq 0 $(($m-1))` 
do 
	for j in `seq 0 $(($n-1))` 
	do 
		read x[$(($n*$i+$j))] 
	done 
done 

echo "Enter the elements for second matrix" 
for i in `seq 0 $(($m-1))` 
do 
	for j in `seq 0 $(($n-1))` 
	do 
		read y[$(($n*$i+$j))] 
		z[$(($n*$i+$j))]=$((${x[$(($n*$i+$j))]}+${y[$(($n*$i+$j))]})) 
	done 
done 

echo "Matrix after addition is" 
for i in `seq 0 $(($m-1))` 
do 
	for j in `seq 0 $(($n-1))` 
	do 
		echo -ne "${z[$(($n*$i+$j))]}\t" 
	done 
	echo -e "\n" 
done 

exit 0

Ook al zijn er beperkingen voor het implementeren van arrays binnen shell-scripting, het wordt in een handvol situaties nuttig, vooral als we te maken hebben met commandovervanging. Vanuit administratief oogpunt heeft het concept van arrays de weg vrijgemaakt voor de ontwikkeling van veel achtergrondscripts in GNU/Linux-systemen.