ເຮັດວຽກກັບ Arrays ໃນ Linux Shell Scripting - Part 8


ພວກເຮົາບໍ່ສາມາດຈິນຕະນາການພາສາການຂຽນໂປແກຼມໂດຍບໍ່ມີແນວຄວາມຄິດກ່ຽວກັບອາຄານ. ມັນບໍ່ເປັນຫຍັງມັນຈະຖືກປະຕິບັດໃນບັນດາພາສາຕ່າງໆ. ແທນທີ່ປ້າຍຈະຊ່ວຍພວກເຮົາໃນການລວມຂໍ້ມູນ, ຄ້າຍຄືກັນຫຼືແຕກຕ່າງກັນ, ພາຍໃຕ້ຊື່ສັນຍາລັກ ໜຶ່ງ.

ນີ້ຄືກັບວ່າພວກເຮົາມີຄວາມກັງວົນໃຈກ່ຽວກັບການຂຽນ ໜັງ ສືແກະ, ບົດຂຽນນີ້ຈະຊ່ວຍທ່ານໃນການຫຼີ້ນຮອບດ້ວຍສະຄິບແກະທີ່ເຮັດໃຫ້ການ ນຳ ໃຊ້ແນວຄວາມຄິດກ່ຽວກັບອາຄານນີ້.

Array Initialization ແລະການ ນຳ ໃຊ້

ດ້ວຍຮູບແບບ ໃໝ່ ຂອງ bash, ມັນສະ ໜັບ ສະ ໜູນ ອາຄານ ໜຶ່ງ ມິຕິ. ອາເລສາມາດຖືກປະກາດຢ່າງຈະແຈ້ງໂດຍ ປະກາດ ຫອຍທີ່ສ້າງຂຶ້ນ.

declare -a var  

ແຕ່ວ່າມັນບໍ່ ຈຳ ເປັນຕ້ອງປະກາດຕົວປ່ຽນແປງຕ່າງໆຕາມທີ່ກ່າວມາຂ້າງເທິງ. ພວກເຮົາສາມາດໃສ່ອົງປະກອບສ່ວນຕົວເພື່ອຈັດລຽງໂດຍກົງດັ່ງຕໍ່ໄປນີ້.

var[XX]=<value>

ບ່ອນທີ່ ‘XX’ ໝາຍ ເຖິງດັດຊະນີແຖວ. ເພື່ອແຍກອົງປະກອບຂບວນການໃຊ້ syntax ວົງເລັບ, i.e.

${var[XX]}

ໝາຍ ເຫດ: ການດັດສະນີ Array ສະເຫມີເລີ່ມຕົ້ນດ້ວຍ 0.

ອີກວິທີ ໜຶ່ງ ທີ່ສະດວກໃນການເລີ່ມຕົ້ນອາເລັນທັງ ໝົດ ແມ່ນໂດຍການໃຊ້ວົງເລັບຄູ່ຕາມຮູບຂ້າງລຸ່ມ.

var=( element1 element2 element3 . . . elementN )

ຍັງມີອີກວິທີ ໜຶ່ງ ຂອງການ ກຳ ຫນົດຄ່າຕ່າງໆໃຫ້ແກ່ອາຄານ. ວິທີການເລີ່ມຕົ້ນນີ້ແມ່ນ ໝວດ ຍ່ອຍຂອງວິທີການທີ່ໄດ້ອະທິບາຍຜ່ານມາ.

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

ພວກເຮົາຍັງສາມາດອ່ານ/ມອບຄ່າຕ່າງໆເພື່ອຈັດລຽງໃນໄລຍະເວລາປະຕິບັດໂດຍໃຊ້ ອ່ານ ແກະທີ່ສ້າງຂຶ້ນ.

read -a array

ໃນປັດຈຸບັນເມື່ອປະຕິບັດຄໍາຖະແຫຼງຂ້າງເທິງນີ້ພາຍໃນສະຄິບ, ມັນລໍຖ້າການປ້ອນຂໍ້ມູນບາງຢ່າງ. ພວກເຮົາຕ້ອງສະ ໜອງ ອົງປະກອບຂອງຂບວນທີ່ແຍກອອກຈາກພື້ນທີ່ (ແລະບໍ່ແມ່ນລົດຂົນສົ່ງກັບຄືນ). ຫລັງຈາກເຂົ້າຄ່າແລ້ວກົດປຸ່ມ enter ເພື່ອຢຸດ.

ເພື່ອຂ້າມຜ່ານອົງປະກອບຂບວນພວກເຮົາຍັງສາມາດໃຊ້ ສຳ ລັບ loop.

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

ຂ້ອຍຄິດວ່າມັນບໍ່ມີຄວາມ ໝາຍ ຫຍັງໃນການອະທິບາຍບົດຂຽນຂ້າງເທິງນີ້ຢ່າງລະອຽດເພາະມັນເປັນການອະທິບາຍດ້ວຍຕົນເອງ. ຖ້າ ຈຳ ເປັນຂ້ອຍຈະອຸທິດສ່ວນ ໜຶ່ງ ໃນຊຸດນີ້ໂດຍສະເພາະກ່ຽວກັບການ ໝູນ ໃຊ້ສາຍສະຕິງ.

ການທົດແທນ ຄຳ ສັ່ງມອບ ໝາຍ ຜົນຜະລິດຂອງ ຄຳ ສັ່ງຫລືຫລາຍ ຄຳ ສັ່ງເຂົ້າໃນສະພາບການອື່ນ. ທີ່ນີ້ໃນສະພາບການຂອງຂບວນນີ້ພວກເຮົາສາມາດສະແດງຜົນຜະລິດຂອງ ຄຳ ສັ່ງເປັນສ່ວນປະກອບຂອງອາຄານ. Syntax ແມ່ນດັ່ງຕໍ່ໄປນີ້.

array=( $(command) )

ໂດຍຄ່າເລີ່ມຕົ້ນເນື້ອໃນຂອງຜົນຜະລິດຂອງ ຄຳ ສັ່ງແຍກອອກໂດຍຊ່ອງຫວ່າງສີຂາວຖືກຕິດໃສ່ເປັນແຖວເປັນສ່ວນປະກອບສ່ວນຕົວ ສະຄິບຕໍ່ໄປນີ້ບອກເນື້ອໃນຂອງໄດເລກະທໍລີ, ເຊິ່ງແມ່ນເອກະສານທີ່ມີສິດ 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

ພວກເຮົາສາມາດເປັນຕົວແທນຂອງຕາຕະລາງຂະ ໜາດ 2 ມິຕິໄດ້ຢ່າງງ່າຍດາຍໂດຍໃຊ້ວົງມົນຂະ ໜາດ 1 ມິຕິ. ໃນ ແຖວ ຄຳ ສັ່ງທີ່ ສຳ ຄັນ ອົງປະກອບການເປັນຕົວແທນໃນແຕ່ລະແຖວຂອງຕາຕະລາງຖືກເກັບຮັກສາໄວ້ເປັນ ລຳ ດັບໃນດັດສະນີເປັນແຖວຕາມ ລຳ ດັບ. ສຳ ລັບຕາຕະລາງ 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 

ເຖິງແມ່ນວ່າຈະມີຂໍ້ ຈຳ ກັດໃນການຈັດຕັ້ງປະຕິບັດອາຄານພາຍໃນແກະສະຄິບ, ມັນຈະກາຍເປັນປະໂຫຍດໃນສະຖານະການ ຈຳ ນວນ ໜຶ່ງ, ໂດຍສະເພາະເມື່ອພວກເຮົາຈັດການກັບ ຄຳ ສັ່ງແທນ ເບິ່ງຈາກມຸມມອງດ້ານການບໍລິຫານ, ແນວຄວາມຄິດຂອງຂບວນການໄດ້ປູທາງໄປສູ່ການພັດທະນາສະຄິບພື້ນຫລັງຫລາຍໆຢ່າງໃນລະບົບ GNU/Linux.