ເຮັດໃຫ້ເລິກເຂົ້າໄປໃນ Function Complexities ດ້ວຍ Shell Scripting - ພາກທີ VII
ບົດຂຽນທີ່ຜ່ານມາຂອງຂ້ອຍກ່ຽວກັບ "ຄວາມເຂົ້າໃຈແລະການຂຽນບົດບາດໃນ Shell Scripts" ອາດຈະໃຫ້ທ່ານມີແນວຄວາມຄິດພື້ນຖານກ່ຽວກັບວິທີການຂຽນ ໜ້າ ທີ່ພາຍໃຕ້ສະຄຣິບແກະ ດຽວນີ້ເຖິງເວລາແລ້ວທີ່ຈະເຂົ້າໄປໃນຄຸນລັກສະນະທີ່ເປັນປະໂຫຍດຫລາຍຂື້ນເຊັ່ນ: ການ ນຳ ໃຊ້ຕົວແປທ້ອງຖິ່ນແລະການເອີ້ນຄືນ.
ສິ່ງທີ່ເຮັດໃຫ້ຕົວປ່ຽນແປງໃນທ້ອງຖິ່ນ? ມັນຂື້ນຢູ່ກັບຕັນນັ້ນໂດຍສະເພາະບ່ອນທີ່ຕົວແປຖືກປະກາດ. ຕົວປ່ຽນແປງທີ່ຖືກປະກາດເປັນ ທ້ອງຖິ່ນ ຈະສາມາດເຂົ້າເຖິງໄດ້ຈາກລະຫັດທ່ອນນັ້ນບ່ອນທີ່ມັນປະກົດຢູ່ໃນຂອບເຂດຂອງມັນຢູ່ໃນທ້ອງຖິ່ນ ເພື່ອອະທິບາຍສິ່ງນີ້ໃຫ້ເບິ່ງໃນຕົວຢ່າງ ໜຶ່ງ ລຸ່ມນີ້.
#!/bin/bash func( ) { local i=10 j=20 echo "i from func = $i" echo "j from func = $j" } echo "i outside func = $i" echo "j outside func = $j" func echo "i outside func = $i" echo "j outside func = $j" exit 0
ກ່ຽວກັບການປະຕິບັດຕົວອັກສອນຂ້າງເທິງຜົນຜະລິດຈະເປັນ.
i outside func = j outside func = i from func = 10 j from func = 20 i outside func = j outside func = 20
ນີ້ແມ່ນຍ້ອນວ່າ ໜ້າ ທີ່ ມ່ວນຊື່ນ ຍັງບໍ່ທັນໄດ້ຖືກເອີ້ນເທື່ອໃນຂະນະທີ່ ຄຳ ຖະແຫຼງ 2 ສະບັບຂອງແອັກໂກ້ ທຳ ອິດຖືກປະຕິບັດ. ຫຼັງຈາກການໂທຫາຟັງຊັນ ມ່ວນຊື່ນ ຄຳ ຖະແຫຼງການຂອງແອັກໂກ້ 2 ຄຳ ດຽວກັນກໍ່ໃຫ້ເກີດຜົນຕ່າງກັນ. ດຽວນີ້ຕົວປ່ຽນ j ທີ່ຖືກປະກາດພາຍໃນ func ແລະບໍ່ແມ່ນໃນທ້ອງຖິ່ນ, ສາມາດເຂົ້າເບິ່ງໄດ້ພາຍຫລັງ.
ດັ່ງນັ້ນຄ່າ ສຳ ລັບ j ຈະກາຍເປັນ 20. ຈະເປັນແນວໃດກ່ຽວກັບຕົວປ່ຽນແປງຂອງທ້ອງຖິ່ນ i ? ເນື່ອງຈາກຂອບເຂດຂອງມັນຢູ່ໃນ ໜ້າ ທີ່ ມ່ວນຊື່ນ , ມູນຄ່າ 10 ບໍ່ສາມາດເຂົ້າມາຈາກພາຍນອກໄດ້. ໃຫ້ສັງເກດວ່າຕົວແປ j ທີ່ຖືກປະກາດຕາມປົກກະຕິພາຍໃນ func ແມ່ນທົ່ວໂລກໂດຍຄ່າເລີ່ມຕົ້ນ.
ໃນປັດຈຸບັນທ່ານມີຄວາມຄຸ້ນເຄີຍກັບຕົວແປທ້ອງຖິ່ນແລະວິທີການນໍາໃຊ້ມັນພາຍໃນທ່ອນໄມ້ທີ່ເຮັດວຽກ. ຂໍໃຫ້ພວກເຮົາກ້າວໄປຫາພາກທີ່ ໜ້າ ສົນໃຈທີ່ສຸດພາຍໃຕ້ ໜ້າ ທີ່, ການເອີ້ນຄືນ.
ໜ້າ ທີ່ເອີ້ນຕົວເອງໂດຍທົ່ວໄປເອີ້ນວ່າຂັ້ນຕອນການເອີ້ນຄືນ. ຫຼືມັນສາມາດຖືກ ກຳ ນົດວ່າເປັນການສະແດງລະບົບການຄິດໄລ່ໂດຍການ ນຳ ໃຊ້ແບບງ່າຍດາຍຂອງລະບົບ algorithm ດຽວກັນນັ້ນ. ພິຈາລະນາຕົວຢ່າງຂອງການຄົ້ນຫາຄວາມຈິງຂອງເລກ. ພວກເຮົາຮູ້ແລ້ວວ່າ n! = 1 x 2 x 3 x … x (n-1) x n. ດັ່ງນັ້ນພວກເຮົາສາມາດຂຽນຄວາມ ສຳ ພັນທີ່ເກີດຂື້ນຄື:
n! = (n-1)! x n
ສະນັ້ນມັນງ່າຍ ສຳ ລັບພວກເຮົາທີ່ຈະເອີ້ນຄືນການເຮັດວຽກແບບດຽວກັນຄືນ ໃໝ່ ແລະໃຊ້ມູນຄ່າການກັບມາຈາກການໂທແຕ່ລະຄັ້ງເພື່ອຄູນກັບຜົນໄດ້ຮັບທີ່ຜ່ານມາ, i.e.
5! = 4! x 5 4! = 3! x 4 3! = 2! x 3 2! = 1! x 2 1! = 0! x 1
ໃນທີ່ນີ້ພວກເຮົາພະຍາຍາມຂຽນຄິບເພື່ອຊອກຫາຄວາມຈິງຂອງຕົວເລກໂດຍໃຊ້ຕົວແປທ້ອງຖິ່ນແລະການເອີ້ນຄືນ.
#!/bin/bash fact( ) { local num=$1 if [ $num -eq 0 ]; then ret=1 else temp=$((num-1)) fact $temp ret=$((num*$?)) fi return $ret } fact 5 echo "Factorial of 5 = $?" exit 0
ຕົວເລກ ແມ່ນຕົວແປທ້ອງຖິ່ນທີ່ໃຊ້ເພື່ອເກັບຄ່າແຕ່ລະ N-1 ຕາມແຕ່ລະໂທ. ນີ້ສະພາບພື້ນຖານຈະກວດເບິ່ງວ່າຕົວເລກເທົ່າກັບເລກສູນຫຼືບໍ່ (ນັບຕັ້ງແຕ່ 0! = 1 ແລະຂໍ້ມູນຈິງບໍ່ໄດ້ຖືກ ກຳ ນົດ ສຳ ລັບຕົວເລກລົບ). ເມື່ອມາຮອດສະພາບພື້ນຖານນີ້ມັນຈະສົ່ງຄືນຄ່າ 1 ໃຫ້ກັບຜູ້ໂທ. ດຽວນີ້ ຈຳ ນວນ = 1 ແລະ ret = 1 x 1 .
ໃນທັນທີນີ້ມັນກັບຄືນ 1 ກັບຜູ້ໂທຂອງມັນ. ດຽວນີ້ ຈຳ ນວນ = 2 ແລະ ret = 2 x 1 ແລະອື່ນໆ. ສຸດທ້າຍເມື່ອ ຕົວເລກ = 5 ມູນຄ່າກັບຄືນຈະເປັນ 24 ແລະຜົນສຸດທ້າຍແມ່ນ ret = 5 x 24 . ຜົນສຸດທ້າຍ 120 ແມ່ນຖືກສົ່ງໄປຫາ ຄຳ ຖະແຫຼງການຂອງຜູ້ໂທແລະຖືກສະແດງ.
ມີບັນຫາ ໜຶ່ງ ໃນຄິບຂ້າງເທິງ. ດັ່ງທີ່ຂ້າພະເຈົ້າໄດ້ອະທິບາຍໃນບົດຂຽນກ່ອນ ໜ້າ ນີ້, ໜ້າ ທີ່ບໍ່ສາມາດກັບຄືນເລກເຕັມໃຫຍ່ໄດ້. ດັ່ງນັ້ນເບື້ອງຊ້າຍຂອງມັນຕໍ່ຜູ້ໃຊ້ເພື່ອຫາທາງອອກ ສຳ ລັບບັນຫາຂ້າງເທິງ.
ຖາມ. ພວກເຮົາສາມາດປະຕິບັດການເອີ້ນຄືນໂດຍບໍ່ໃຊ້ຕົວແປທ້ອງຖິ່ນໄດ້ບໍ? ຄຳ ຕອບແມ່ນແມ່ນແລ້ວ.
ເບິ່ງຕົວຢ່າງຕໍ່ໄປນີ້ ສຳ ລັບການສະແດງຊຸດ Fibonacci ໂດຍການ ນຳ ໃຊ້ການເອີ້ນຄືນ. ຄວາມ ສຳ ພັນພື້ນຖານແມ່ນ:
fib(0) = 0 fib(1) = 1 else fib(n) = fib(n-1) + fib(n-2) Fibonacci series using recursion #!/bin/bash fib( ) { a=$1 if [ $a -lt 2 ]; then echo $a else ((--a)) b=$(fib $a) ((--a)) c=$(fib $a) echo $((b+c)) fi } for i in $(seq 0 15) do out=$(fib $i) echo $out done exit 0
ບໍ່ມີຕົວແປໃນທ້ອງຖິ່ນຖືກໃຊ້ໃນຄິບຂ້າງເທິງ. ຂ້າພະເຈົ້າຫວັງວ່າທ່ານຈະສາມາດເຂົ້າໃຈກະແສສະຄິບໃນລະຫວ່າງການປະຕິບັດ.
ນີ້ແມ່ນຄ່າ 15 ໝາຍ ເຖິງ ຈຳ ນວນ ຄຳ ສັບໃນຊຸດ Fibonacci ທີ່ຈະສະແດງ. ທ່ານໄດ້ສັງເກດເຫັນສິ່ງໃດທີ່ພິເສດກ່ຽວກັບການປະຕິບັດຕົວອັກສອນຂ້າງເທິງ. ໃຊ້ເວລາໄລຍະ ໜຶ່ງ, ບໍ່ແມ່ນບໍ? ການເອີ້ນຄືນໃນບົດຂຽນແມ່ນຊ້າກວ່າການເອີ້ນຄືນໃນພາສາການຂຽນໂປແກຼມເຊັ່ນ: C.
ດ້ວຍບົດຂຽນນີ້, ຂ້າພະເຈົ້າວາງແຜນທີ່ຈະສະຫຼຸບພາກສ່ວນທີ່ເຮັດ ໜ້າ ທີ່ໃນການຂຽນ ໜັງ ສືແກະ. ປັບປຸງ ໃໝ່ ດ້ວຍ Tecmint ເພື່ອໃຫ້ມີບົດຄວາມກ່ຽວກັບອາທິການແລະອີກຫລາຍຢ່າງທີ່ຈະມາເຖິງ…