Back to Question Center
0

ການປະຕິບັດງານ Async ໃນການປະຕິບັດງານ Redux ຕິກິຣິຍາ            ກິດຈະກໍາ Async ໃນ React Redux Applications ຫົວຂໍ້ສໍາຄັນ: Raw Semalt

1 answers:
ການປະຕິບັດງານ Async ໃນ React Redux Applications

ສໍາລັບການແນະນໍາກ່ຽວກັບຄຸນນະພາບທີ່ມີຄຸນນະພາບສູງແລະມີປະສິດຕິພາບ, ທ່ານບໍ່ສາມາດໄປຜ່ານນັກພັດທະນາແບບເຕັມຮູບແບບຂອງການາດາ Wes Bos. ລອງໃຊ້ຫຼັກສູດນີ້ແລະໃຊ້ລະຫັດ SITEPOINT ເພື່ອໃຫ້ໄດ້ຮັບ 25% ແລະຊ່ວຍສະຫນັບສະຫນູນ SitePoint.

ນີ້ໄດ້ຖືກຈັດພີມມາຢູ່ໃນ Codebrahma.

Semalt ເປັນພາສາການຂຽນໂປແກຼມດຽວ - high watt vape mod starter. ນັ້ນແມ່ນ, ເມື່ອທ່ານມີລະຫັດບາງຢ່າງເຊັ່ນນີ້ .

Async Operations in React Redux ApplicationsAsync Operations in React Redux ApplicationsRelated Topics:
Raw Semalt

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

ເປັນຫຍັງຂ້ອຍຈຶ່ງສະແດງການໂທ API ເທົ່ານັ້ນ (ການຮ້ອງຂໍເຄືອຂ່າຍ) ທີ່ນີ້? ຈະເປັນແນວໃດກ່ຽວກັບການດໍາເນີນງານ async ອື່ນໆ? ການໂທ API ແມ່ນເປັນຕົວຢ່າງທີ່ງ່າຍດາຍແລະເປັນປະໂຫຍດສໍາລັບການອະທິບາຍວິທີການຈັດການກັບການດໍາເນີນງານແບບບໍ່ກົງກັນ. ມີການດໍາເນີນງານອື່ນໆເຊັ່ນ: setTimeout , ການຄິດໄລ່ການປະຕິບັດງານຫນັກ, ການໂຫຼດຮູບພາບແລະການດໍາເນີນງານທີ່ມີເຫດການໃດໆ.

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

ການລະເມີດລະຫັດນີ້:

     userId = fetch (userEndPoint) // fetish userId ຈາກ userEndpointuserDetails = fetch (userEndpoint, userId) // fetcher for this userId ໂດຍເສພາະ     

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

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

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

  • ຊັດເຈນລະຫັດ
  • ຄວາມສາມາດຂະຫຍາຍໄດ້
  • ຄວາມງ່າຍໃນການຈັດການຂໍ້ຜິດພາດ.

ສໍາລັບແຕ່ລະວິທີ, ພວກເຮົາຈະປະຕິບັດການໂທ API ທັງສອງນີ້:

1 ການຫາ ເມືອງ ຈາກ userDetails (ການຕອບສະຫນອງ API ຄັ້ງທໍາອິດ)

ໃຫ້ສົມມຸດວ່າຈຸດສຸດທ້າຍແມ່ນ / ລາຍລະອຽດ . ມັນຈະມີເມືອງໃນການຕອບໂຕ້. ການຕອບສະຫນອງຈະເປັນວັດຖຸ:

     userDetails: {.ເມືອງ: 'ເມືອງ',.}    

2. ອີງໃສ່ຜູ້ໃຊ້ ເມືອງ ພວກເຮົາຈະລວບລວມຮ້ານອາຫານຢູ່ໃນເມືອງ

ໃຫ້ເວົ້າວ່າຈຸດສຸດທ້າຍແມ່ນ / restuarants /: ເມືອງ . ການຕອບສະຫນອງຈະເປັນອາເລ:

     ['restaurant1', 'restaurant2',]    

ຈື່ໄວ້ວ່າພວກເຮົາສາມາດເຮັດຄໍາຮ້ອງຂໍທີສອງໄດ້ເທົ່ານັ້ນເມື່ອພວກເຮົາສໍາເລັດການເຮັດວຽກຄັ້ງທໍາອິດ (ເນື່ອງຈາກວ່າມັນຂຶ້ນກັບຄໍາຮ້ອງຂໍຄັ້ງທໍາອິດ).

ໂດຍສະເພາະຂ້ອຍໄດ້ເລືອກວິທີການຂ້າງເທິງນີ້ເພາະວ່າພວກມັນແມ່ນໃຊ້ໄດ້ຫຼາຍທີ່ສຸດສໍາລັບໂຄງການຂະຫນາດໃຫຍ່. ຍັງມີວິທີອື່ນອີກທີ່ສາມາດສະເພາະກັບວຽກງານພິເສດແລະບໍ່ມີຄຸນສົມບັດທັງຫມົດທີ່ຕ້ອງການສໍາລັບແອັບຯທີ່ສະລັບສັບຊ້ອນ ( reducedx-async, reduced-promise, reducex-async-queue ເພື່ອໃຫ້ຊື່ ນ້ອຍ).

ຄໍາສັນຍາ

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

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

     componentDidMount    {axios get ('/ details') // Get user details ຫຼັງຈາກນັ້ນ (ຕອບ = & gt {const userCity = response ເມືອງaxios get (`/ restaurants / $ {userCity}`). ຫຼັງຈາກນັ້ນ (restaurantResponse = & gt {ນີ້. setState ({listOfResaurants: restaurantResponse, // Set the state})})})}    

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

Async / wait ແມ່ນການປະຕິບັດໃຫມ່ທີ່ພວກເຮົາສາມາດເຮັດໃຫ້ການປະຕິບັດງານ async. ຕົວຢ່າງເຊັ່ນສິ່ງດຽວກັນນີ້ສາມາດບັນລຸໄດ້ໂດຍ:

     async componentDidMount    {const restaurantResponse = await axios get ('/ details') // Get user details ຫຼັງຈາກນັ້ນ (ຕອບ = & gt {const userCity = response ເມືອງaxios get (`/ restaurants / $ {userCity}`). ຫຼັງຈາກນັ້ນ (restaurantResponse = & gt restaurantResponse})ນີ້. setState ({restaurantResponse,})}    

ທັງສອງນີ້ແມ່ນແບບງ່າຍທີ່ສຸດຂອງວິທີການທັງຫມົດ. Semalt ເຫດຜົນທັງຫມົດແມ່ນພາຍໃນອົງປະກອບ, ພວກເຮົາໄດ້ຢ່າງງ່າຍດາຍສາມາດດຶງຂໍ້ມູນທັງຫມົດເມື່ອການໂຫຼດຂອງອົງປະກອບ.

ຜົນເສຍຫາຍໃນວິທີການ

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

Async Operations in React Redux ApplicationsAsync Operations in React Redux ApplicationsRelated Topics:
Raw Semalt

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

ວິທີທີ່ພວກເຮົາສາມາດປັບປຸງຈາກບ່ອນນີ້ໄດ້ບໍ?

1 ການຈັດການລັດ
ໃນກໍລະນີເຫຼົ່ານີ້, ການນໍາໃຊ້ຮ້ານທົ່ວໂລກກໍ່ຈະແກ້ໄຂເຄິ່ງຫນຶ່ງຂອງບັນຫາຂອງພວກເຮົາ. ພວກເຮົາຈະໃຊ້ Redux ເປັນຮ້ານຄ້າທົ່ວໂລກຂອງພວກເຮົາ.

2. ການເຄື່ອນຍ້າຍເຫດຜົນທາງທຸລະກິດເພື່ອແກ້ໄຂສະຖານທີ່
ຖ້າພວກເຮົາຄິດເຖິງການເຄື່ອນຍ້າຍຕາມເຫດຜົນທາງດ້ານທຸລະກິດຂອງພວກເຮົາພາຍນອກສ່ວນປະກອບ, ຫຼັງຈາກນັ້ນບ່ອນທີ່ພວກເຮົາສາມາດເຮັດໄດ້ແນວໃດ? ໃນການກະທໍາ? ໃນການຫຼຸດລົງ? ຜ່ານ middleware? ສະຖາປັດຕະຍະກໍາຂອງ Redux ແມ່ນດັ່ງນັ້ນມັນເປັນການ synchronous ໃນລັກສະນະ. ໃນເວລາທີ່ທ່ານສົ່ງການດໍາເນີນການ (ສິ່ງຂອງ JS) ແລະມັນໄປເຖິງຮ້ານ, ຜູ້ປະຕິບັດງານຈະປະຕິບັດຕາມມັນ.

3. ການຂຸດເຈາະມີຫົວຂໍ້ແຍກທີ່ມີລະຫັດ async ຖືກປະຕິບັດແລະການປ່ຽນແປງໃດໆກັບສະຖານະສາກົນສາມາດເອີ້ນໄດ້ຜ່ານການສະຫມັກ

Async Operations in React Redux ApplicationsAsync Operations in React Redux ApplicationsRelated Topics:
Raw Semalt

ຈາກນີ້, ພວກເຮົາສາມາດໄດ້ຮັບຄວາມຄິດທີ່ວ່າຖ້າພວກເຮົາກໍາລັງເຄື່ອນຍ້າຍທັງຫມົດຕາມເຫດຜົນຍ້ອນກັບມາກ່ອນທີ່ຈະຫຼຸດລົງ - ມັນແມ່ນການປະຕິບັດຫຼືການໃຊ້ middleware - ມັນເປັນໄປໄດ້ທີ່ຈະສົ່ງການກະທໍາທີ່ຖືກຕ້ອງໃນເວລາທີ່ຖືກຕ້ອງ.
ສໍາລັບຕົວຢ່າງ, ເມື່ອການຄົ້ນຫາເລີ້ມຕົ້ນ, ພວກເຮົາສາມາດສົ່ງ ({type: 'FETCH_STARTED'} , ແລະເມື່ອມັນສິ້ນສຸດແລ້ວ, ພວກເຮົາສາມາດສົ່ງ ({type: 'FETCH_SUCCESS'}) . ມັນພື້ນຖານອະນຸຍາດໃຫ້ພວກເຮົາກັບຄືນ ການເຮັດວຽກ ແທນທີ່ຈະ ວັດຖຸ ເປັນການປະຕິບັດ. ສິ່ງນີ້ຊ່ວຍໃຫ້ການສະຫນອງ ການສົ່ງ ແລະ getState ເປັນການໂຕ້ຖຽງສໍາລັບການເຮັດວຽກ. ພວກເຮົາໃຊ້ການຈັດສົ່ງທີ່ມີປະສິດຕິຜົນໂດຍການສົ່ງການກະທໍາທີ່ຈໍາເປັນໃນເວລາທີ່ເຫມາະສົມ. ຜົນປະໂຫຍດແມ່ນ:

  • ອະນຸຍາດໃຫ້ມີການສົ່ງອອກຫຼາຍພາຍໃນຫນ້າທີ່
  • ກ່ຽວກັບເຫດຜົນທາງທຸລະກິດທີ່ຈະເອົາໄປຢູ່ນອກປະຕິກິລິຍາ React ແລະຍ້າຍໄປປະຕິບັດ.

ໃນກໍລະນີຂອງພວກເຮົາ, ພວກເຮົາສາມາດຂຽນຄືນການປະຕິບັດດັ່ງນີ້:

     export const getRestaurants =    = & gt {return (dispatch) = & gt {dispatch (fetchStarted   ) // fetchStarted    ຄືນຜົນກະທົບfetch ('/ details'). ຫຼັງຈາກນັ້ນ ((ຕອບ) = & gt {dispatch (fetchUserDetailsSuccess   ) // fetchUserDetailsSuccess ຄືນຜົນກະທົບreturn response}) ຫຼັງຈາກນັ້ນ (ລາຍລະອຽດ = & gt ລາຍລະອຽດເມືອງ). ຫຼັງຈາກນັ້ນ (city = & gt fetch ('/ restaurants / city')). ຫຼັງຈາກນັ້ນ ((ຕອບ) = & gt {dispatch (fetchRestaurantsSuccess (ຕອບສະຫນອງ)) // fetchRestaurantsSuccess (ຕອບສະຫນອງ) ສົ່ງກັບການດໍາເນີນການກັບຂໍ້ມູນ}) catch (   = & gt dispatch (fetchError   )) // fetchError    ຄືນຜົນກະທົບກັບສິ່ງທີ່ຜິດພາດ}}    

ດັ່ງທີ່ທ່ານສາມາດເຫັນໄດ້, ພວກເຮົາມີການຄວບຄຸມທີ່ດີເວລາທີ່ຈະສົ່ງ ການຈັດສົ່ງ ສິ່ງປະເພດໃດແດ່. fetchUserDetailsSuccess , fetchRestaurantsSuccess and fetchError dispatches an object JavaScript plain of a ພິມແລະລາຍລະອຽດເພີ່ມເຕີມຖ້າຕ້ອງການ. ສະນັ້ນໃນປັດຈຸບັນມັນເປັນວຽກຂອງຜູ້ຫຼຸດຜ່ອນຄວາມໄວໃນການຈັດການກັບການປະຕິບັດແຕ່ລະຄົນແລະປັບປຸງເບິ່ງ. ຂ້າພະເຈົ້າບໍ່ໄດ້ປຶກສາຫາລືກ່ຽວກັບການຫຼຸດຜ່ອນຄວາມມັນ, ເນື່ອງຈາກວ່າມັນງ່າຍດາຍຈາກທີ່ນີ້ແລະການປະຕິບັດອາດຈະແຕກຕ່າງກັນ.

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

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

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

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

ການໃຊ້ Redux-Saga

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

Semalt ສະຫນອງ API ທີ່ຊ່ວຍໃຫ້ບັນລຸດັ່ງຕໍ່ໄປນີ້:

  • ກັ້ນເຫດການທີ່ບລັອກກະທູ້ໃນເສັ້ນດຽວຈົນກວ່າບາງສິ່ງບາງຢ່າງຈະບັນລຸ
  • ກິດຈະກໍາທີ່ບໍ່ແມ່ນການບີບບັງຄັບທີ່ເຮັດໃຫ້ລະຫັດ async
  • ການຈັດການແຂ່ງຂັນລະຫວ່າງຄໍາຮ້ອງຂໍທີ່ຫຼາກຫຼາຍ
  • ຢຸດຊົ່ວຄາວ / ປິດບັງ / ປະຕິເສດການກະທໍາໃດໆ.

ເຮັດແນວໃດ sagas ເຮັດວຽກ?

Sagas ນໍາໃຊ້ການຜະສົມຜະສານຂອງ ES6 generators ແລະ async await APIs ເພື່ອງ່າຍການດໍາເນີນງານ async. ມັນໂດຍພື້ນຖານແລ້ວການເຮັດວຽກຂອງຕົນກ່ຽວກັບກະທູ້ແຍກຕ່າງຫາກທີ່ພວກເຮົາສາມາດເຮັດໄດ້ຫຼາຍ API ໂທ. ພວກເຮົາສາມາດນໍາໃຊ້ API ຂອງພວກເຂົາເພື່ອເຮັດໃຫ້ການໂທແຕ່ລະປະສົມປະສານຫລືບໍ່ກົງກັນຂ້າມຂຶ້ນຢູ່ກັບກໍລະນີການນໍາໃຊ້. API ສະຫນອງການເຮັດວຽກທີ່ພວກເຮົາສາມາດເຮັດໃຫ້ກະທູ້ທີ່ລໍຖ້າຢູ່ໃນເສັ້ນດຽວກັນຈົນກ່ວາຄໍາຮ້ອງຂໍກັບຄືນຄໍາຕອບ. Semalt ຈາກນີ້, ມີຫຼາຍ API ອື່ນໆທີ່ສະຫນອງໃຫ້ໂດຍຫ້ອງສະຫມຸດນີ້, ເຊິ່ງເຮັດໃຫ້ຄໍາຮ້ອງຂໍ API ຫຼາຍງ່າຍທີ່ຈະຈັດການ. ເມືອງ));// ກ່ຽວກັບການຈັດສົ່ງສົບຜົນສໍາເລັດຂອງຮ້ານອາຫານyield put ({ພິມ: 'FETCH_RESTAURANTS_SUCCESS',payload: {ຮ້ານອາຫານ},})} catch (e) {// On error ສົ່ງຂໍ້ຄວາມສະແດງຂໍ້ຜິດພະລາດyield put ({ພິມ: 'FETCH_RESTAURANTS_ERROR',payload: {errorMessage: e,}})}}ສົ່ງອອກຫນ້າທີ່ທໍາອິດ * fetchRestaurantSagaMonitor {yield takeEvery ('FETCH_RESTAURANTS', fetchInitial) // ເອົາຄໍາຮ້ອງຂໍດັ່ງກ່າວທຸກໆຄັ້ງ}

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

  • ເມື່ອການຮ້ອງຂໍຄັ້ງທໍາອິດເລີ່ມ
  • ເມື່ອຄໍາຮ້ອງຂໍຄັ້ງທໍາອິດສໍາເລັດ
  • ເມື່ອຄໍາຮ້ອງຂໍທີສອງເລີ່ມຕົ້ນ

.ແລະອື່ນໆ.

ນອກຈາກນີ້, ທ່ານສາມາດເບິ່ງຄວາມງາມຂອງ fetchRestaurantsSaga . ພວກເຮົາໄດ້ຖືກນໍາໃຊ້ໃນປັດຈຸບັນ API ການໂທສໍາລັບການປະຕິບັດການສະກັດການໂທ. Sagas ສະຫນອງ APIs ອື່ນໆ, ເຊັ່ນ: fork , ເຊິ່ງປະຕິບັດການເອີ້ນບໍ່ສະກັດ. ພວກເຮົາສາມາດສົມທົບການສະກັດກັ້ນແລະການປິດການໂທອອກເພື່ອຮັກສາໂຄງສ້າງທີ່ເຫມາະສົມກັບຄໍາຮ້ອງສະຫມັກຂອງພວກເຮົາ.

ໃນຄວາມເປັນໄປໄດ້, ການໃຊ້ sagas ແມ່ນມີຜົນປະໂຫຍດ:

  • ພວກເຮົາສາມາດສ້າງໂຄງສ້າງແລະກຸ່ມ sagas ອີງໃສ່ວຽກງານໃດຫນຶ່ງ. ພວກເຮົາສາມາດເຮັດໃຫ້ຫນຶ່ງ saga ຈາກຄົນອື່ນໂດຍພຽງແຕ່ສົ່ງການກະທໍາ.
  • ເນື່ອງຈາກວ່າມັນເປັນ middleware, ການກະທໍາທີ່ພວກເຮົາຂຽນຈະເປັນວັດຖຸ JS ທໍາມະດາ, ບໍ່ເຫມືອນກັບ thunks.
  • ນັບຕັ້ງແຕ່ພວກເຮົາຍ້າຍເຫດຜົນທາງທຸລະກິດພາຍໃນ sagas (ເຊິ່ງເປັນ middleware), ຖ້າພວກເຮົາຮູ້ວ່າຈະເປັນການເຮັດວຽກຂອງ saga, ຫຼັງຈາກນັ້ນເຂົ້າໃຈສ່ວນຂອງ React ມັນຈະງ່າຍກວ່າ.
  • ຂໍ້ຜິດພາດສາມາດຕິດຕາມໄດ້ງ່າຍແລະສົ່ງໄປທີ່ຮ້ານໂດຍຜ່ານຮູບແບບການລອງ / ຈັບ.

ການໃຊ້ Redux-Observables

ດັ່ງທີ່ໄດ້ກ່າວໄວ້ໃນເອກະສານຂອງພວກເຂົາພາຍໃຕ້ "Epic ເປັນຫຼັກທໍາອິດຂອງການຫຼຸດລົງທີ່ສາມາດສັງເກດໄດ້":

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

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

ສໍາລັບວຽກງານຂອງພວກເຮົາ, ພວກເຮົາພຽງແຕ່ສາມາດຂຽນນີ້ໄດ້:

     const fetchUserDetails = action $ = & gt (action $ ofType ('FETCH_RESTAURANTS'). switchMap (   = & gtajax getJSON ('/ details'). ແຜນທີ່ (ການຕອບສະຫນອງ = & gt ຕອບ userDetails ເມືອງ). switchMap (   = & gtajax getJSON (`/ restaurants / city /`). ແຜນທີ່ (ຕອບ = & gt ({ປະເພດ: 'FETCH_RESTAURANTS_SUCCESS', payload: ການຕອບສະຫນອງຮ້ານອາຫານ))) // ການສົ່ງອອກຫຼັງຈາກປະສົບຜົນສໍາເລັດ) catch (error = & gt; Observable of ({type: 'FETCH_USER_DETAILS_FAILURE', error})))))    

ໃນຄັ້ງທໍາອິດ, ນີ້ອາດຈະມີຄວາມສັບສົນຫນ້ອຍ. ແຕ່ຫຼາຍທ່ານເຂົ້າໃຈ RxJS, ມັນງ່າຍທີ່ຈະສ້າງ Epic.

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

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

ຄວາມຕ້ອງການຂອງຂ້ອຍ

ທ່ານຈະກໍານົດວິທີການໃຊ້ຫ້ອງສະຫມຸດໃດແດ່?
ມັນຂຶ້ນຢູ່ກັບຄວາມສະລັບຊັບຊ້ອນ API ຂອງພວກເຮົາ. ທັງສອງແມ່ນແນວຄວາມຄິດທີ່ແຕກຕ່າງກັນແຕ່ເທົ່າທຽມກັນດີພໍ. ຂ້າພະເຈົ້າຂໍແນະນໍາໃຫ້ພະຍາຍາມທັງເບິ່ງວ່າໃຜເຫມາະສົມກັບທ່ານທີ່ດີທີ່ສຸດ.

ບ່ອນໃດທີ່ທ່ານຮັກສາເຫດຜົນທາງທຸລະກິດຂອງທ່ານທີ່ກ່ຽວຂ້ອງກັບ APIs?
ດີກວ່າກ່ອນທີ່ຈະຫຼຸດລົງ, ແຕ່ບໍ່ແມ່ນຢູ່ໃນອົງປະກອບ. ວິທີການທີ່ດີທີ່ສຸດຈະຢູ່ໃນ middleware (ໃຊ້ sagas ຫຼື observables).

ທ່ານສາມາດອ່ານເພິ່ມເຕີມກະທູ້ການພັດທະນາໃນ Codebrahma.

Async Operations in React Redux ApplicationsAsync Operations in React Redux ApplicationsRelated Topics:
Raw Semalt
ວິທີທີ່ດີທີ່ສຸດທີ່ຈະຮຽນຮູ້ສໍາລັບຜູ້ເລີ່ມໃຫມ່
Wes Bos
ຫຼັກສູດການຝຶກອົບຮົມຂັ້ນຕອນໂດຍຂັ້ນຕອນເພື່ອໃຫ້ທ່ານສ້າງໂລກແທ້ຈິງ. js + Firebase apps ແລະອົງປະກອບເວັບໄຊທ໌ໃນສອງສາມຕອນແລງ. ໃຊ້ລະຫັດຄູປອງ 'SITEPOINT' ທີ່ເຊັກເອົາເພື່ອຮັບ 25% .

March 1, 2018