Schafft mat Arrays am Linux Shell Scripting - Deel 8

Mir kënnen eis eng Programméierungssprooch net virstellen ouni d'Konzept vun Arrays. Et ass egal wéi se tëscht verschiddene Sproochen ëmgesat ginn. Amplaz Arrays hëllefen eis Daten, ähnlech oder anescht, ënner engem symboleschen Numm ze konsolidéieren.

Hei wéi mir eis iwwer Shell-Skripten besuergt sinn, hëlleft dësen Artikel Iech mat e puer Shell-Skripte ze spillen, déi dëst Konzept vun Arrays benotzen.

Array Initialiséierung a Benotzung

Mat méi nei Versioune vu Bash ënnerstëtzt et eendimensional Arrays. En Array kann explizit vun der declare Shell-builtin deklaréiert ginn.

declare -a var  

Awer et ass net néideg Arrayvariablen ze deklaréieren wéi hei uewen. Mir kënnen eenzel Elementer direkt an d'Array setzen wéi follegt.

var[XX]=<value>

wou 'XX' den Arrayindex bezeechent. Fir d'Array-Elementer z'ënnerscheeden, benotzt d'Curly Bracket Syntax, d.h.

${var[XX]}

Notiz: Array Indexéierung fänkt ëmmer mat 0 un.

Eng aner praktesch Manéier fir e ganze Array z'initialiséieren ass andeems Dir d'Paarthese benotzt wéi hei ënnendrënner.

var=( element1 element2 element3 . . . elementN )

Et gëtt nach eng aner Manéier fir Wäerter un Arrays ze ginn. Dëse Wee vun der Initialiséierung ass eng Ënnerkategorie vun der virdru erkläerter Method.

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

Mir kënnen och Wäerter fir Array während der Ausféierungszäit liesen/zouzeweisen mat der read Shell-builtin.

read -a array

Elo wann Dir déi uewe genannte Ausso an engem Skript ausféiert, waart et op e puer Input. Mir mussen d'Array-Elementer ubidden, getrennt vum Raum (an net Kutsch zréck). Nodeems Dir d'Wäerter aginn hutt, dréckt Enter fir ofzeschléissen.

Fir duerch d'Array Elementer duerchzegoen, kënne mir och fir Loop benotzen.

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

Déi folgend Skript resüméiert den Inhalt vun dëser spezieller Sektioun.

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

Vill vun de Standard String Operatiounen funktionnéieren op Arrays. Kuckt de folgende Probeskript deen e puer Operatiounen op Arrays implementéiert (inklusiv Stringoperatiounen).

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

Folgend ass den Output produzéiert beim Ausféierung vum uewe genannte Skript.

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

Ech mengen et ass keng Bedeitung fir dat uewe genannte Skript am Detail z'erklären well et selbstänneg ass. Wann néideg wäert ech en Deel an dëser Serie exklusiv op Stringmanipulatiounen widmen.

Kommando Ersatz gëtt den Ausgang vun engem Kommando oder verschidde Kommandoen an en anere Kontext zou. Hei an dësem Kontext vun Arrays kënne mir den Ausgang vu Kommandoen als eenzel Elementer vun Arrays asetzen. Syntax ass wéi follegt.

array=( $(command) )

Par défaut sinn d'Inhalter an der Ausgab vum Kommando getrennt vu wäisse Plazen an d'Array als individuell Elementer ugeschloss. Déi folgend Skript lëscht den Inhalt vun engem Verzeechnes, dat sinn Dateien mat 755 Permissiounen.

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

Mir kënnen einfach eng 2-zweedimensional Matrix representéieren mat engem 1-zweedimensionalen Array. An Zeil Haaptuerdnung Representatiounselementer an all Zeil vun enger Matrix ginn progressiv an Array-Indexen op sequenziell Manéier gespäichert. Fir eng mXn Matrix, Formel fir déi selwecht kann geschriwwe ginn als.

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

Kuckt en anert Probeskript fir 2 Matrizen ze addéieren an déi resultéierend Matrix ze drécken.

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

Och wann et Aschränkungen fir d'Ëmsetzung vun Arrays am Shell-Skript ass, gëtt et an enger Handvoll Situatiounen nëtzlech, besonnesch wa mir mat Kommandosubstitutioun handelen. Aus enger administrativer Siicht kuckt, huet d'Konzept vun Arrays de Wee gemaach fir d'Entwécklung vu ville Background Scripten an GNU/Linux Systemer.