ലിനക്സ് ഷെൽ സ്ക്രിപ്റ്റിംഗിൽ അറേകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നു - ഭാഗം 8

അറേകൾ എന്ന ആശയമില്ലാതെ ഒരു പ്രോഗ്രാമിംഗ് ഭാഷ നമുക്ക് സങ്കൽപ്പിക്കാൻ കഴിയില്ല. വിവിധ ഭാഷകൾക്കിടയിൽ അവ എങ്ങനെ നടപ്പിലാക്കുന്നു എന്നത് പ്രശ്നമല്ല. പകരം ഒരു പ്രതീകാത്മക നാമത്തിൽ സമാനമോ വ്യത്യസ്തമോ ആയ ഡാറ്റ ഏകീകരിക്കാൻ അറേകൾ ഞങ്ങളെ സഹായിക്കുന്നു.

ഇവിടെ ഷെൽ സ്uക്രിപ്റ്റിംഗിനെക്കുറിച്ച് ഞങ്ങൾക്ക് ആശങ്കയുണ്ട്, ഈ അറേകളുടെ ആശയം ഉപയോഗിക്കുന്ന ചില ഷെൽ സ്uക്രിപ്റ്റുകൾ ഉപയോഗിച്ച് കളിക്കാൻ ഈ ലേഖനം നിങ്ങളെ സഹായിക്കും.

അറേ ഇനീഷ്യലൈസേഷനും ഉപയോഗവും

ബാഷിന്റെ പുതിയ പതിപ്പുകൾക്കൊപ്പം, ഇത് ഏകമാന ശ്രേണികളെ പിന്തുണയ്ക്കുന്നു. ഷെൽ-ബിൽറ്റിൻ declare വഴി ഒരു അറേ വ്യക്തമായി പ്രഖ്യാപിക്കാൻ കഴിയും.

declare -a var  

എന്നാൽ മുകളിൽ പറഞ്ഞതുപോലെ അറേ വേരിയബിളുകൾ പ്രഖ്യാപിക്കേണ്ട ആവശ്യമില്ല. ഇനിപ്പറയുന്ന രീതിയിൽ നേരിട്ട് അറേ ചെയ്യാൻ നമുക്ക് വ്യക്തിഗത ഘടകങ്ങൾ ചേർക്കാം.

var[XX]=<value>

ഇവിടെ 'XX' എന്നത് അറേ സൂചികയെ സൂചിപ്പിക്കുന്നു. അറേ എലമെന്റുകൾ പരിഗണിക്കുന്നതിന് ചുരുണ്ട ബ്രാക്കറ്റ് വാക്യഘടന ഉപയോഗിക്കുക, അതായത്.

${var[XX]}

ശ്രദ്ധിക്കുക: അറേ ഇൻഡക്uസിംഗ് എപ്പോഴും 0-ൽ ആരംഭിക്കുന്നു.

ഒരു മുഴുവൻ ശ്രേണിയും സമാരംഭിക്കുന്നതിനുള്ള മറ്റൊരു സൗകര്യപ്രദമായ മാർഗ്ഗം ചുവടെ കാണിച്ചിരിക്കുന്നതുപോലെ ഒരു ജോടി പരാന്തീസിസ് ഉപയോഗിച്ചാണ്.

var=( element1 element2 element3 . . . elementN )

അറേകൾക്ക് മൂല്യങ്ങൾ നൽകുന്നതിന് മറ്റൊരു മാർഗമുണ്ട്. ഈ ഇനീഷ്യലൈസേഷൻ വഴി മുമ്പ് വിശദീകരിച്ച രീതിയുടെ ഒരു ഉപവിഭാഗമാണ്.

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

നിർവ്വഹണ സമയത്ത് read shell-builtin ഉപയോഗിച്ച് നമുക്ക് മൂല്യങ്ങൾ അറേയിലേക്ക് വായിക്കാനും നിയോഗിക്കാനും കഴിയും.

read -a array

ഇപ്പോൾ ഒരു സ്ക്രിപ്റ്റിനുള്ളിൽ മുകളിലുള്ള പ്രസ്താവന നടപ്പിലാക്കുമ്പോൾ, അത് കുറച്ച് ഇൻപുട്ടിനായി കാത്തിരിക്കുന്നു. സ്പെയ്സ് കൊണ്ട് വേർതിരിച്ച അറേ ഘടകങ്ങൾ ഞങ്ങൾ നൽകേണ്ടതുണ്ട് (അല്ലാതെ ക്യാരേജ് റിട്ടേൺ അല്ല). മൂല്യങ്ങൾ നൽകിയ ശേഷം അവസാനിപ്പിക്കാൻ എന്റർ അമർത്തുക.

അറേ എലമെന്റുകളിലൂടെ സഞ്ചരിക്കാൻ നമുക്ക് ലൂപ്പിനും ഉപയോഗിക്കാം.

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

ഇനിപ്പറയുന്ന സ്ക്രിപ്റ്റ് ഈ പ്രത്യേക വിഭാഗത്തിന്റെ ഉള്ളടക്കങ്ങൾ സംഗ്രഹിക്കുന്നു.

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

സ്റ്റാൻഡേർഡ് സ്ട്രിംഗ് ഓപ്പറേഷനുകളിൽ പലതും അറേകളിൽ പ്രവർത്തിക്കുന്നു. അറേകളിൽ (സ്ട്രിംഗ് ഓപ്പറേഷനുകൾ ഉൾപ്പെടെ) ചില പ്രവർത്തനങ്ങൾ നടപ്പിലാക്കുന്ന ഇനിപ്പറയുന്ന സാമ്പിൾ സ്ക്രിപ്റ്റ് നോക്കുക.

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

മുകളിലെ സ്ക്രിപ്റ്റ് എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ ലഭിക്കുന്ന ഔട്ട്പുട്ട് താഴെ കൊടുക്കുന്നു.

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

മേൽപ്പറഞ്ഞ സ്uക്രിപ്റ്റ് സ്വയം വിശദീകരിക്കുന്നതിനാൽ വിശദമായി വിശദീകരിക്കുന്നതിൽ അർത്ഥമില്ലെന്ന് ഞാൻ കരുതുന്നു. ആവശ്യമെങ്കിൽ ഞാൻ ഈ പരമ്പരയിലെ ഒരു ഭാഗം സ്ട്രിംഗ് കൃത്രിമത്വത്തിന് മാത്രമായി സമർപ്പിക്കും.

കമാൻഡ് സബ്സ്റ്റിറ്റ്യൂഷൻ ഒരു കമാൻഡിന്റെയോ ഒന്നിലധികം കമാൻഡുകളുടെയോ ഔട്ട്പുട്ട് മറ്റൊരു സന്ദർഭത്തിലേക്ക് അസൈൻ ചെയ്യുന്നു. ഇവിടെ അറേകളുടെ ഈ സന്ദർഭത്തിൽ നമുക്ക് കമാൻഡുകളുടെ ഔട്ട്പുട്ട് അറേകളുടെ വ്യക്തിഗത ഘടകങ്ങളായി ചേർക്കാം. വാക്യഘടന ഇപ്രകാരമാണ്.

array=( $(command) )

സ്വതവേ, വൈറ്റ് സ്uപെയ്uസുകളാൽ വേർതിരിച്ച കമാൻഡിന്റെ ഔട്ട്uപുട്ടിലെ ഉള്ളടക്കങ്ങൾ വ്യക്തിഗത ഘടകങ്ങളായി അറേയിലേക്ക് പ്ലഗ് ചെയ്uതിരിക്കുന്നു. ഇനിപ്പറയുന്ന സ്ക്രിപ്റ്റ് ഒരു ഡയറക്ടറിയുടെ ഉള്ളടക്കങ്ങൾ പട്ടികപ്പെടുത്തുന്നു, അവ 755 അനുമതികളുള്ള ഫയലുകളാണ്.

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

1-ഡൈമൻഷണൽ അറേ ഉപയോഗിച്ച് നമുക്ക് ഒരു 2-ഡൈമൻഷണൽ മാട്രിക്സ് എളുപ്പത്തിൽ പ്രതിനിധീകരിക്കാൻ കഴിയും. വരി പ്രധാന ക്രമത്തിൽ ഒരു മാട്രിക്സിന്റെ ഓരോ വരിയിലെയും പ്രാതിനിധ്യ ഘടകങ്ങൾ ക്രമാനുഗതമായ രീതിയിൽ അറേ സൂചികകളിൽ ക്രമാനുഗതമായി സംഭരിക്കുന്നു. ഒരു mXn മാട്രിക്സിനായി, അതിനുള്ള ഫോർമുല ഇങ്ങനെ എഴുതാം.

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

2 മെട്രിക്സ് ചേർക്കുന്നതിനും ഫലമായുണ്ടാകുന്ന മാട്രിക്സ് പ്രിന്റ് ചെയ്യുന്നതിനും മറ്റൊരു മാതൃക സ്ക്രിപ്റ്റ് നോക്കുക.

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

ഷെൽ സ്ക്രിപ്റ്റിംഗിനുള്ളിൽ അറേകൾ നടപ്പിലാക്കുന്നതിന് പരിമിതികൾ ഉണ്ടെങ്കിലും, ഒരുപിടി സാഹചര്യങ്ങളിൽ ഇത് ഉപയോഗപ്രദമാകും, പ്രത്യേകിച്ചും കമാൻഡ് സബ്സ്റ്റിറ്റ്യൂഷൻ ഉപയോഗിച്ച് നമ്മൾ കൈകാര്യം ചെയ്യുമ്പോൾ. ഒരു അഡ്മിനിസ്ട്രേറ്റീവ് വീക്ഷണകോണിൽ നിന്ന് നോക്കുമ്പോൾ, അറേകൾ എന്ന ആശയം ഗ്നു/ലിനക്സ് സിസ്റ്റങ്ങളിൽ നിരവധി പശ്ചാത്തല സ്ക്രിപ്റ്റുകൾ വികസിപ്പിക്കുന്നതിന് വഴിയൊരുക്കി.