ວິທີການໃຊ້ອາກິວເມັນເລີ່ມຕົ້ນໃນຟັງຊັນ?

ວິທີການໃຊ້ອາກິວເມັນເລີ່ມຕົ້ນໃນຟັງຊັນ?

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

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

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

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

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

ການກໍານົດ arguments ເລີ່ມຕົ້ນໃນຟັງຊັນ

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

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

arguments ເລີ່ມຕົ້ນສະຫນອງ a ວິທີທີ່ມີປະສິດທິພາບ ແລະງ່າຍດາຍທີ່ຈະກໍານົດພຶດຕິກໍາທີ່ກໍານົດໄວ້ລ່ວງຫນ້າ⁢ສໍາລັບຫນ້າທີ່. ນີ້ແມ່ນເປັນປະໂຫຍດໂດຍສະເພາະໃນກໍລະນີທີ່ຕ້ອງການພາລາມິເຕີທາງເລືອກຫຼືເວລາທີ່ທ່ານຕ້ອງການໃຫ້ຄ່າເລີ່ມຕົ້ນທີ່ຈະຖືກນໍາໃຊ້ຫຼາຍທີ່ສຸດ. ນອກຈາກນັ້ນ, ການນໍາໃຊ້ arguments ເລີ່ມຕົ້ນສາມາດປັບປຸງການອ່ານລະຫັດຂອງທ່ານໂດຍການກໍາຈັດຄວາມຕ້ອງການທີ່ຈະຜ່ານຄ່າຢ່າງຕໍ່ເນື່ອງເພື່ອປະຕິບັດຫນ້າພາລາມິເຕີໃນເວລາທີ່ການປ່ຽນແປງພຶດຕິກໍາສະເພາະແມ່ນບໍ່ຈໍາເປັນ. ໂດຍການນໍາໃຊ້ຫນ້າທີ່ນີ້, ຜູ້ຂຽນໂປລແກລມສາມາດສຸມໃສ່ລັກສະນະທີ່ສໍາຄັນທີ່ສຸດຂອງເຫດຜົນຂອງຟັງຊັນ, ໂດຍບໍ່ຕ້ອງກັງວົນກ່ຽວກັບລາຍລະອຽດເລັກນ້ອຍຂອງມູນຄ່າການໂຕ້ຖຽງ.

ຂໍ້ໄດ້ປຽບຂອງການໃຊ້ arguments ເລີ່ມຕົ້ນໃນຟັງຊັນ

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

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

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

Syntax ເພື່ອປະຕິບັດ arguments ເລີ່ມຕົ້ນໃນຟັງຊັນ

ໃນການຂຽນໂປລແກລມ, ມັນເປັນເລື່ອງທໍາມະດາທີ່ຈະພົບກັບສະຖານະການທີ່ພວກເຮົາຈໍາເປັນຕ້ອງກໍານົດຄ່າເລີ່ມຕົ້ນສໍາລັບ ⁢the arguments of⁤ a function. ນີ້ເຮັດໃຫ້ພວກເຮົາມີຄວາມສາມາດໃນການກໍາຫນົດຄ່າໃນກໍລະນີທີ່ບໍ່ມີການໂຕ້ຖຽງໃຫ້ໃນເວລາທີ່ໂທຫາຟັງຊັນ. ໃນພາສາການຂຽນໂປລແກລມສ່ວນໃຫຍ່ມັນງ່າຍດາຍແລະເຂົ້າໃຈງ່າຍ.

ວິທີການທົ່ວໄປທີ່ຈະຕັ້ງ arguments ເລີ່ມຕົ້ນໃນຟັງຊັນແມ່ນກໍານົດຄ່າໂດຍກົງໃນຄໍານິຍາມຟັງຊັນ. ຍົກ​ຕົວ​ຢ່າງ:

"ງູເຫຼືອມ"
def⁤ ທັກທາຍ(name='friend'):
ພິມ('ສະບາຍດີ', ຊື່)

ທັກທາຍ() #ຈະພິມ 'ສະບາຍດີເພື່ອນ'
greet('Juan') # ຈະພິມ 'ສະບາຍດີ Juan'
«`

ໃນ⁢ຕົວຢ່າງນີ້, ຟັງຊັນ 'ທັກທາຍ' ມີ argument ຫນຶ່ງ 'ຊື່' ແລະຄ່າເລີ່ມຕົ້ນສໍາລັບການໂຕ້ຖຽງນັ້ນແມ່ນ 'ເພື່ອນ'. ຖ້າຟັງຊັນຖືກເອີ້ນໂດຍບໍ່ມີການໂຕ້ຖຽງໃດໆ, 'ສະບາຍດີເພື່ອນ' ຈະຖືກພິມ. ແນວໃດກໍ່ຕາມ, ຖ້າຄ່າຖືກສະໜອງໃຫ້ໃນເວລາເອີ້ນຟັງຊັນ, ຄ່ານັ້ນຈະຖືກໃຊ້ແທນຄ່າເລີ່ມຕົ້ນ ⁤value⁢.

ອີກວິທີຫນຶ່ງທີ່ຈະກໍານົດ arguments ເລີ່ມຕົ້ນແມ່ນໂດຍການໃຊ້ຕົວປະຕິບັດການມອບຫມາຍພາຍໃນຟັງຊັນ. ຍົກ​ຕົວ​ຢ່າງ:

"`ຈາວາສະຄຣິບ
ຟັງຊັນທັກທາຍ(ຊື່) {
name = ຊື່ || 'ເພື່ອນ';
⁤ console.log('ສະບາຍດີ '‍ +‍ ຊື່);
}

ທັກທາຍ(); // ຈະພິມ 'ສະບາຍດີເພື່ອນ'
ທັກທາຍ('John'); // ຈະພິມ 'ສະບາຍດີ Juan'
«`

ໃນ​ກໍ​ລະ​ນີ​ນີ້, ຖ້າ​ຫາກ​ວ່າ​ຄ່າ​ຂອງ `ຊື່` ແມ່ນ falsy (ນັ້ນ​ແມ່ນ, ມັນ​ປະ​ເມີນ​ເປັນ​ຜິດ), ຄ່າ `'ເພື່ອນ'` ຈະ​ໄດ້​ຮັບ​ການ​ກໍາ​ນົດ​ໂດຍ​ໃຊ້​ຕົວ​ປະ​ຕິ​ບັດ​ການ​ມອບ​ຫມາຍ `||`. ວິທີນີ້, ຖ້າບໍ່ມີການໂຕ້ຖຽງຖືກສະຫນອງໃຫ້ໃນເວລາທີ່ໂທຫາຟັງຊັນ, ຄ່າເລີ່ມຕົ້ນຈະຖືກນໍາໃຊ້.

ມັນເປັນສິ່ງສໍາຄັນທີ່ຈະສັງເກດວ່າໃນເວລາທີ່ໃຊ້ argument ເລີ່ມຕົ້ນໃນຟັງຊັນ, ມັນຈໍາເປັນຕ້ອງພິຈາລະນາຄໍາສັ່ງຂອງ arguments ທີ່ມີຄ່າເລີ່ມຕົ້ນຄວນຈະຖືກວາງໄວ້ໃນຕອນທ້າຍຂອງລາຍການ argument ຂອງຟັງຊັນ, ເພາະວ່າພວກມັນບໍ່ຍົກເວັ້ນການໂຕ້ຖຽງຢູ່ກາງ. ຂອງບັນຊີລາຍຊື່ແມ່ນອະນຸຍາດ. ຍົກ​ຕົວ​ຢ່າງ:

"ງູເຫຼືອມ"
def add(a, b=0):
ສົ່ງຄືນ a + b

result1 = add(2, 3) # result1 ຈະເປັນ 5
result2 = add(2) ⁤ # result2 ຈະເປັນ 2, ນັບຕັ້ງແຕ່ b ມີ⁤ ຄ່າເລີ່ມຕົ້ນຂອງ⁢ 0.
«`

ໃນຕົວຢ່າງນີ້, ຟັງຊັນ `add`⁤ ມີສອງ arguments: `a` ແລະ `b`. ຄ່າເລີ່ມຕົ້ນຂອງ ⁤`b` ແມ່ນ `0`, ຊຶ່ງໝາຍຄວາມວ່າ ຖ້າບໍ່ມີອາກິວເມັນທີສອງຖືກສະໜອງໃຫ້ໃນເວລາເອີ້ນຟັງຊັນ, `a` ຈະຖືກເພີ່ມໃສ່ `0`. ໂດຍການວາງ argument ທີ່ມີຄ່າເລີ່ມຕົ້ນໃນຕອນທ້າຍ, ພວກເຮົາສາມາດໂທຫາຟັງຊັນທີ່ມີ argument ດຽວແລະຄ່າເລີ່ມຕົ້ນຈະຖືກນໍາໃຊ້ສໍາລັບການໂຕ້ຖຽງທີສອງ.

ວິທີການກໍານົດຄ່າເລີ່ມຕົ້ນໃຫ້ກັບ arguments ຟັງຊັນ

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

ເພື່ອກໍານົດຄ່າເລີ່ມຕົ້ນໃຫ້ກັບອາກິວເມັນຂອງຟັງຊັນໃນ JavaScript, ພວກເຮົາພຽງແຕ່ສາມາດໃຊ້ຕົວປະຕິບັດການມອບຫມາຍ (=) ໃນຄໍານິຍາມຂອງພາລາມິເຕີຂອງຫນ້າທີ່. ຕົວຢ່າງ, ສົມມຸດວ່າພວກເຮົາມີຫນ້າທີ່ເອີ້ນວ່າ "ຊົມເຊີຍ" ເຊິ່ງໃຊ້ເວລາສອງຄໍາໂຕ້ຖຽງ: "ຊື່" ແລະ "ຂໍ້ຄວາມ". ຖ້າພວກເຮົາຕ້ອງການກໍານົດຄ່າເລີ່ມຕົ້ນຂອງ "ສະບາຍດີ" ກັບ "ຂໍ້ຄວາມ" argument ໃນກໍລະນີທີ່ບໍ່ມີຄ່າ, ພວກເຮົາສາມາດກໍານົດຫນ້າທີ່ດັ່ງຕໍ່ໄປນີ້:

"`ຈາວາສະຄຣິບ
function greet(ຊື່, ຂໍ້​ຄວາມ = "ສະບາຍດີ") {
console.log(ຂໍ້ຄວາມ + « ⁣ » + ຊື່);
}
«`

ເມື່ອພວກເຮົາໂທຫາຟັງຊັນ "ທັກທາຍ" ໂດຍບໍ່ມີການໃຫ້ຄ່າສໍາລັບການໂຕ້ຖຽງ "ຂໍ້ຄວາມ", ຄ່າເລີ່ມຕົ້ນຂອງ "ສະບາຍດີ" ຖືກໃຊ້ໂດຍອັດຕະໂນມັດ. ຕົວຢ່າງ:

"`ຈາວາສະຄຣິບ
ທັກທາຍ(«John»); ⁤// ພິມ: «ສະບາຍດີ Juan»
«`

ຢ່າງໃດກໍຕາມ, ຖ້າພວກເຮົາສະຫນອງມູນຄ່າສໍາລັບການໂຕ້ຖຽງ "ຂໍ້ຄວາມ", ຄ່າທີ່ກໍາຫນົດເອງນີ້ຈະຖືກໃຊ້ແທນຄ່າເລີ່ມຕົ້ນ. ຍົກ​ຕົວ​ຢ່າງ:

"`ຈາວາສະຄຣິບ
ທັກທາຍ("Maria", "ສະບາຍດີ!"); // ພິມ: «ສະບາຍດີ! ມາເຣຍ"
«`

ມັນເປັນສິ່ງສໍາຄັນທີ່ຈະສັງເກດວ່າຄ່າເລີ່ມຕົ້ນແມ່ນໃຊ້ພຽງແຕ່ຖ້າການໂຕ້ຖຽງທີ່ສອດຄ້ອງກັນຖືກຍົກເລີກເມື່ອໂທຫາຫນ້າທີ່ຫຼືຖ້າຄ່າ "ບໍ່ໄດ້ກໍານົດ" ໄດ້ຖືກຖ່າຍທອດຢ່າງຈະແຈ້ງ. ນີ້ຫມາຍຄວາມວ່າຖ້າພວກເຮົາຜ່ານຄ່າ "null", "0" ຫຼື string ຫວ່າງເປົ່າເປັນຄ່າສໍາລັບການໂຕ້ຖຽງ, ຄ່າເລີ່ມຕົ້ນຈະບໍ່ຖືກນໍາໃຊ້ແລະຄ່າທີ່ສະຫນອງໃຫ້ຈະຖືກນໍາໃຊ້ແທນ. ຍົກ​ຕົວ​ຢ່າງ:

"`ຈາວາສະຄຣິບ
ທັກທາຍ(«ເປໂຕ», null); // ພິມ: « null Pedro »
«`

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

ການພິຈາລະນາໃນເວລາທີ່ໃຊ້ arguments ເລີ່ມຕົ້ນໃນຟັງຊັນ

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

1. ກຳນົດຄ່າເລີ່ມຕົ້ນທີ່ຖືກຕ້ອງ: ມັນເປັນສິ່ງ ສຳ ຄັນທີ່ຈະ ກຳ ນົດຄ່າເລີ່ມຕົ້ນທີ່ ເໝາະ ສົມ ສຳ ລັບແຕ່ລະພາລາມິເຕີໃນຟັງຊັນ. ນີ້ກ່ຽວຂ້ອງກັບການພິຈາລະນາປະເພດຂໍ້ມູນທີ່ຄາດໄວ້, ເຊັ່ນດຽວກັນກັບຄ່າທີ່ມີເຫດຜົນຫຼືຫວ່າງເປົ່າທີ່ສາມາດນໍາໃຊ້ເປັນຄ່າເລີ່ມຕົ້ນ. ນອກຈາກນັ້ນ, ມັນເປັນສິ່ງສໍາຄັນທີ່ຈະຮັບປະກັນວ່າຄ່າເລີ່ມຕົ້ນແມ່ນສອດຄ່ອງແລະມີຄວາມກ່ຽວຂ້ອງໃນສະພາບການຂອງຫນ້າທີ່.

2. ຮັກສາຄວາມສອດຄ່ອງໃນເວລາທີ່ໃຊ້ arguments ເລີ່ມຕົ້ນ: ມັນເປັນສິ່ງສໍາຄັນທີ່ຈະສອດຄ່ອງໃນເວລາທີ່ໃຊ້ arguments ເລີ່ມຕົ້ນໃນຟັງຊັນ. ນີ້ກ່ຽວຂ້ອງກັບການປະຕິບັດຕາມສົນທິສັນຍາພາຍໃນລະຫັດຂອງທ່ານແລະໃຫ້ແນ່ໃຈວ່າຫນ້າທີ່ມີມູນຄ່າເລີ່ມຕົ້ນດຽວກັນສໍາລັບພາລາມິເຕີຂອງພວກເຂົາໃນສ່ວນຕ່າງໆຂອງລະຫັດ. ນີ້ຈະເຮັດໃຫ້ມັນງ່າຍຕໍ່ການເຂົ້າໃຈລະຫັດແລະຫຼີກເວັ້ນຄວາມຂັດແຍ້ງຫຼືຄວາມຜິດພາດທີ່ເປັນໄປໄດ້ໃນເວລາທີ່ນໍາໃຊ້ຫນ້າທີ່ຢູ່ໃນສ່ວນຕ່າງໆຂອງໂຄງການ.

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

ຫຼີກເວັ້ນການບໍ່ຊັດເຈນແລະຄວາມຜິດພາດໃນເວລາທີ່ການນໍາໃຊ້ argument ເລີ່ມຕົ້ນ

ການ​ນໍາ​ໃຊ້​ຂອງ​ ການໂຕ້ຖຽງເລີ່ມຕົ້ນ in functions ເປັນເຄື່ອງມືທີ່ເປັນປະໂຫຍດຫຼາຍເພື່ອເຮັດໃຫ້ລະຫັດງ່າຍດາຍແລະປັບປຸງການອ່ານຂອງມັນ. ຢ່າງໃດກໍ່ຕາມ, ມັນເປັນສິ່ງສໍາຄັນທີ່ຈະໃຊ້ຄວາມລະມັດລະວັງບາງຢ່າງເພື່ອຫຼີກເວັ້ນຄວາມບໍ່ແນ່ນອນແລະຄວາມຜິດພາດທີ່ເປັນໄປໄດ້ໃນການປະຕິບັດຂອງມັນ. ນີ້ແມ່ນຄໍາແນະນໍາບາງຢ່າງສໍາລັບການນໍາໃຊ້ການໂຕ້ຖຽງເລີ່ມຕົ້ນຢ່າງມີປະສິດທິພາບ.

ກ່ອນອື່ນ ໝົດ, ມັນ ຈຳ ເປັນ ກໍານົດຢ່າງຈະແຈ້ງ ຄ່າເລີ່ມຕົ້ນໃນເວລາທີ່ການປະກາດຟັງຊັນນີ້ຈະຮັບປະກັນວ່າຫນ້າທີ່ຂອງທ່ານມີຄວາມຊັດເຈນແລະຫຼີກເວັ້ນຄວາມແປກໃຈທີ່ອາດຈະຖືກເອີ້ນດ້ວຍການໂຕ້ຖຽງທີ່ຖືກຍົກເວັ້ນ, ນອກຈາກນັ້ນ, ໂດຍການເຮັດດັ່ງນັ້ນ, ທ່ານຮັບປະກັນວ່າຄ່າໂດຍຄ່າເລີ່ມຕົ້ນແມ່ນສອດຄ່ອງທົ່ວທຸກຫນ້າທີ່ ໂທ.

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

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

ສະຫລຸບລວມແລ້ວ, ການປະຕິບັດຕາມຄໍາແນະນໍາເຫຼົ່ານີ້ຈະຊ່ວຍໃຫ້ທ່ານຫຼີກເວັ້ນຄວາມບໍ່ແນ່ນອນແລະຄວາມຜິດພາດໃນເວລາທີ່ໃຊ້ການໂຕ້ຖຽງເລີ່ມຕົ້ນໃນຫນ້າທີ່ຂອງທ່ານ. ວິທີນີ້ເຈົ້າສາມາດໃຊ້ປະໂຍດອັນເຕັມທີ່ຂອງຄຸນນະສົມບັດນີ້ຂອງ Python ແລະຂຽນລະຫັດທີ່ຊັດເຈນແລະຄວາມຜິດພາດຫນ້ອຍ. ຈື່ໄວ້ ກໍານົດຢ່າງຈະແຈ້ງ ⁢ຄ່າເລີ່ມຕົ້ນ, ⁤ ຫຼີກເວັ້ນການນໍາໃຊ້ຄ່າທີ່ປ່ຽນແປງໄດ້ ແລະຄໍານຶງເຖິງ ກົດລະບຽບຂອບເຂດ ເມື່ອໃຊ້ການໂຕ້ຖຽງເລີ່ມຕົ້ນ.

ຂໍ້​ສະ​ເຫນີ​ແນະ​ສໍາ​ລັບ​ການ​ປະ​ຕິ​ບັດ​ທີ່​ດີກ​ວ່າ​ຂອງ ⁢ arguments default ໃນ​ຫນ້າ​ທີ່

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

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

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

3. Document⁢ ຖືກຕ້ອງ ⁤ arguments ເລີ່ມຕົ້ນ: ມັນເປັນສິ່ງສໍາຄັນທີ່ຈະບັນທຶກການໂຕ້ຖຽງເລີ່ມຕົ້ນຂອງຫນ້າທີ່ຂອງພວກເຮົາຢ່າງຊັດເຈນແລະຊັດເຈນ. ວິທີນີ້, ນັກຂຽນໂປລແກລມອື່ນທີ່ໃຊ້ຫນ້າທີ່ຂອງພວກເຮົາຈະສາມາດເຂົ້າໃຈໄດ້ໄວແລະຊັດເຈນວ່າຄ່າເລີ່ມຕົ້ນແມ່ນຫຍັງແລະພວກເຂົາຄວນໃຊ້ມັນແນວໃດ. ນອກຈາກນັ້ນ, ເອກະສານທີ່ດີຍັງຈະຊ່ວຍໃຫ້ພວກເຮົາຫຼີກເວັ້ນການເຂົ້າໃຈຜິດແລະຄວາມສັບສົນໃນເວລາທີ່ນໍາໃຊ້ຄຸນສົມບັດຂອງພວກເຮົາ.

ໝາຍເຫດ: ກະລຸນາຮັບຊາບວ່າແທັກທີ່ກ້າຫານທີ່ໃຊ້ເພື່ອເນັ້ນໃສ່ຄຳສັບ ຫຼືປະໂຫຍກທີ່ສຳຄັນແມ່ນສະແດງໃນຮູບແບບຂໍ້ຄວາມທຳມະດາຢູ່ທີ່ນີ້ເພື່ອຈຸດປະສົງການສາທິດ, ແຕ່ຄວນໃຊ້ເປັນແທັກ HTML ເມື່ອຈັດຮູບແບບບົດຄວາມຕົວຈິງ.

ໝາຍເຫດ: ກະລຸນາຮັບຊາບວ່າແທັກທີ່ກ້າຫານທີ່ໃຊ້ເພື່ອເນັ້ນໃສ່ປະໂຫຍກ ຫຼືປະໂຫຍກທີ່ສຳຄັນແມ່ນສະແດງຢູ່ໃນຮູບແບບຂໍ້ຄວາມທຳມະດາຢູ່ທີ່ນີ້ເພື່ອຈຸດປະສົງການສາທິດ, ແຕ່ຄວນໃຊ້ເປັນແທັກ HTML ເມື່ອຈັດຮູບແບບບົດຄວາມຕົວຈິງ.

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

ມີຫຼາຍວິທີທີ່ຈະ ໃຊ້ argument ເລີ່ມຕົ້ນໃນຟັງຊັນ.‍ ພວກ​ເຮົາ​ສາ​ມາດ​ປະ​ກາດ​ຄ່າ​ເລີ່ມ​ຕົ້ນ​ໄດ້​ໂດຍ​ກົງ​ໃນ​ຄໍາ​ນິ​ຍາມ​ຂອງ​ການ​ທໍາ​ງານ​ໂດຍ​ນໍາ​ໃຊ້​ syntax ການ​ມອບ​ຫມາຍ​ພາ​ລາ​ມິ​ເຕີ​. ນີ້ ມັນສາມາດເຮັດໄດ້ ການເພີ່ມຄ່າເລີ່ມຕົ້ນທັນທີຫຼັງຈາກຊື່ພາລາມິເຕີ, ແຍກດ້ວຍເຄື່ອງຫມາຍເທົ່າທຽມກັນ. ຕົວຢ່າງ, ພວກເຮົາສາມາດກໍານົດຫນ້າທີ່ເອີ້ນວ່າ "ຊົມເຊີຍ" ທີ່ມີພາລາມິເຕີ "ຊື່" ທີ່ມີຄ່າເລີ່ມຕົ້ນຂອງ "ໂລກ." ນີ້ ໝາຍ ຄວາມວ່າຖ້າພວກເຮົາເອີ້ນຟັງຊັນໂດຍບໍ່ລະບຸຊື່ສະເພາະ, "ໂລກ" ຈະຖືກໃຊ້ເປັນຄ່າຂອງພາລາມິເຕີ.