Arbejde med arrays i Linux Shell Scripting - Del 8

Vi kan ikke forestille os et programmeringssprog uden begrebet arrays. Det betyder ikke noget, hvordan de implementeres på forskellige sprog. I stedet hjælper arrays os med at konsolidere data, ens eller forskellige, under et symbolsk navn.

Her, da vi er bekymrede for shell-scripting, vil denne artikel hjælpe dig med at lege med nogle shell-scripts, der gør brug af dette koncept med arrays.

Initialisering og brug af matrix

Med nyere versioner af bash understøtter den endimensionale arrays. En matrix kan eksplicit erklæres af erklær shell-indbygget.

declare -a var  

Men det er ikke nødvendigt at erklære arrayvariabler som ovenfor. Vi kan indsætte individuelle elementer for at oprette direkte som følger.

var[XX]=<value>

hvor 'XX' angiver matrixindekset. For at afvige arrayelementer skal du bruge den krøllede parentes-syntaks, dvs.

${var[XX]}

Bemærk: Arrayindeksering starter altid med 0.

En anden praktisk måde at initialisere et helt array er ved hjælp af parantesparret som vist nedenfor.

var=( element1 element2 element3 . . . elementN )

Der er endnu en måde at tildele værdier til arrays. Denne måde til initialisering er en underkategori af den tidligere forklarede metode.

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

Vi kan også læse/tildele værdier til array i løbet af udførelsestiden ved hjælp af læse shell-indbygget.

read -a array

Nu efter at have udført ovenstående erklæring inde i et script, venter det på noget input. Vi er nødt til at give arrayelementerne adskilt af mellemrum (og ikke vognretur). Efter indtastning af værdierne skal du trykke på enter for at afslutte.

For at krydse gennem matrixelementerne kan vi også bruge til loop.

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

Følgende script opsummerer indholdet af dette afsnit.

#!/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

Mange af standardstrengoperationer fungerer på arrays. Se på følgende eksempelscript, der implementerer nogle operationer på arrays (inklusive strengoperationer).

#!/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

Følgende er output produceret ved udførelse af ovenstående 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

Jeg tror, der er ingen betydning i at forklare ovenstående script i detaljer, da det er selvforklarende. Om nødvendigt vil jeg dedikere en del i denne serie udelukkende til strengmanipulationer.

Kommandosubstitution tildeler output fra en kommando eller flere kommandoer i en anden sammenhæng. Her i denne sammenhæng med arrays kan vi indsætte output af kommandoer som individuelle elementer i arrays. Syntaks er som følger.

array=( $(command) )

Som standard er indholdet i output af kommando adskilt af hvide mellemrum tilsluttet array som individuelle elementer. Følgende script viser indholdet af en mappe, der er filer med 755 tilladelser.

#!/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

Vi kan let repræsentere en 2-dimensionel matrix ved hjælp af et 1-dimensionelt array. I række større rækkefølge repræsentationselementer i hver række i en matrix lagres gradvist i matrixindekser på en sekventiel måde. For en mXn-matrix kan formel for det samme skrives som.

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

Se på et andet eksempelscript for at tilføje 2 matricer og udskrive den 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 

Selvom der er begrænsninger for implementering af arrays i shell-scripting, bliver det nyttigt i en håndfuld situationer, især når vi håndterer kommandosubstitution. Set fra et administrativt synspunkt banede begrebet arrays vejen for udvikling af mange baggrundsskripter i GNU/Linux-systemer.