Back to Question Center
0

ອົງປະກອບຄໍາສັ່ງສູງສຸດ: ຮູບແບບການປະຕິບັດຄໍາຮ້ອງຮຽນແບບຕອບໂຕ້            ອົງປະກອບຄໍາສັ່ງສູງສຸດ: ການປະຕິບັດຄໍາຮ້ອງສະຫມັກການປະຕິບັດຄໍາຮ້ອງສະຫມັກ PatternRelated Semalt: ES6AngularJSAjaxReactjQueryMore Sponsors

1 answers:
ອົງປະກອບທີ່ສູງກວ່າຄໍາສັ່ງ: ຮູບແບບການຕອບສະຫນອງຄໍາຮ້ອງຮຽນ

ບົດຄວາມນີ້ແມ່ນໂດຍຜູ້ຂຽນຜູ້ຂຽນ Jack Franklin . ຕອບສະຫນອງຂອງເຈົ້າຫນ້າທີ່ SitePoint ເພື່ອເຮັດໃຫ້ທ່ານມີເນື້ອຫາທີ່ຫນ້າສົນໃຈຈາກນັກຂຽນທີ່ສໍາຄັນແລະຜູ້ເວົ້າຂອງຊຸມຊົນ JavaScript

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

ສົມບັດສິນ

ຟັງຊັນທີ່ຖືວ່າເປັນບໍລິສຸດຖ້າມັນມີຄຸນສົມບັດຕໍ່ໄປນີ້:

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

ຕົວຢ່າງເຊັ່ນ ເສີມ ດ້ານລຸ່ມແມ່ນບໍລິສຸດ:

  function add (x, y) {return x + y}    

ຢ່າງໃດກໍຕາມ, ຫນ້າທີ່ badAdd ຂ້າງລຸ່ມນີ້ແມ່ນບໍ່ສະອາດ:

  var y = 2function badAdd (x) {return x + y}    

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

  var y = 2badAdd  
// 5y = 3badAdd
// 6

ອ່ານເພີ່ມເຕີມກ່ຽວກັບຫນ້າທີ່ບໍລິສຸດທີ່ທ່ານສາມາດອ່ານໄດ້ "ການແນະນໍາການຂຽນໂປຼແກຼມທີ່ສົມເຫດສົມຜົນ" ໂດຍ Mark Brown - mysql business analytics.

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

ຟັງຊັນທີ່ສູງກວ່າ

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

ໃຫ້ເວົ້າວ່າພວກເຮົາມີຫນ້າທີ່ ຂອງພວກເຮົາ ຈາກຂ້າງເທິງ, ແລະພວກເຮົາຕ້ອງການຂຽນຂໍ້ຄວາມບາງຢ່າງເພື່ອວ່າເມື່ອພວກເຮົາໂທຫາມັນ, ພວກເຮົາຈະບັນທຶກຜົນໄດ້ຮັບໃຫ້ console ກ່ອນທີ່ຈະສົ່ງຜົນໄດ້ຮັບ. ພວກເຮົາບໍ່ສາມາດແກ້ໄຂ ຕື່ມ function, ດັ່ງນັ້ນແທນທີ່ພວກເຮົາສາມາດສ້າງຫນ້າທີ່ໃຫມ່:

  function addAndLog (x, y) {var result = add (x, y)console log ('ຜົນໄດ້ຮັບ', ຜົນໄດ້ຮັບ);return result}    

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

  function logAndReturn (func) {return function    {var args = Array prototype slice. call (arguments)var result = func ສະຫມັກ (null, args);console log ('ຜົນໄດ້ຮັບ', ຜົນໄດ້ຮັບ);return result}}    

ໃນປັດຈຸບັນພວກເຮົາສາມາດໃຊ້ຟັງຊັນນີ້ແລະໃຊ້ມັນເພື່ອເພີ່ມການເຂົ້າສູ່ ຕື່ມ ແລະ ລົບ :

  var addAndLog = logAndReturn (add)addAndLog (4, 4) // 8 ຖືກສົ່ງກັບ, 'Result 8' ຖືກເຂົ້າສູ່ລະບົບvar subtractAndLog = logAndReturn (subtract)subtractAndLog (4, 3) // 1 is returned, 'Result 1' is logged    

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

ນອກຈາກນີ້, ທ່ານສາມາດກວດສອບການ Semalt ນີ້, ເຊິ່ງສະແດງໃຫ້ເຫັນລະຫັດຂ້າງເທິງໃນການດໍາເນີນການ.

ສ່ວນປະກອບຄໍາສັ່ງສູງ

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

ໃນສ່ວນນີ້, ພວກເຮົາກໍາລັງໃຊ້ React Router, ການແກ້ໄຂເສັ້ນທາງຈິງຂອງ React. ຖ້າທ່ານຕ້ອງການເລີ່ມຕົ້ນດ້ວຍຫ້ອງສະຫມຸດ, ຂ້າພະເຈົ້າແນະນໍາໃຫ້ແນະນໍາ React Router Tutorial ໃນ GitHub.

ຕິກິລິຍາສ່ວນເຊື່ອມຕໍ່ຂອງ Router

React Router ສະຫນອງອົງປະກອບ ທີ່ໃຊ້ໃນການເຊື່ອມຕໍ່ລະຫວ່າງຫນ້າໃນໃບຄໍາຮ້ອງ React. ຫນຶ່ງໃນຄຸນສົມບັດທີ່ອົງປະກອບນີ້ ໃຊ້ແມ່ນ activeClassName . ໃນເວລາທີ່ ມີຄຸນສົມບັດນີ້ແລະມັນປະຈຸບັນມີການເຄື່ອນໄຫວ (ຜູ້ໃຊ້ແມ່ນຢູ່ໃນ URL ທີ່ຈຸດເຊື່ອມຕໍ່ກັບ), ອົງປະກອບຈະໄດ້ຮັບການໃຫ້ຊັ້ນນີ້, ເຮັດໃຫ້ນັກພັດທະນາສາມາດລົງມັນໄດ້.

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

   ຫະນ້າທໍາອິດ  ກ່ຽວກັບ  ຕິດຕໍ່     

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

ແທນທີ່ຈະ, ພວກເຮົາສາມາດຂຽນອົງປະກອບທີ່ເຊື່ອມຕໍ່ກັບອົງປະກອບ :

  var AppLink = React createClass ({render: function    {ກັບມາ ({this props ເດັກນ້ອຍ})}})    

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

   ຫະນ້າທໍາອິດ  ກ່ຽວກັບ  ຕິດຕໍ່     

ທ່ານສາມາດເບິ່ງຕົວຢ່າງນີ້ທີ່ເຮັດວຽກໃນ Plunker.

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

ອົງປະກອບທີ່ປະຕິບັດງານ, ທີ່ຢູ່ອາໄສ

ປະຕິກິລິຍາ 0 14 ແນະນໍາສະຫນັບສະຫນູນສໍາລັບອົງປະກອບທີ່ມີປະໂຫຍດ, ທີ່ບໍ່ມີປະເທດ. Semalt ແມ່ນສ່ວນປະກອບທີ່ມີຄຸນລັກສະນະດັ່ງຕໍ່ໄປນີ້:

  • ພວກເຂົາບໍ່ມີລັດໃດ
  • ພວກເຂົາບໍ່ນໍາໃຊ້ວິທີການປະຕິບັດງານຂອງ React (ເຊັ່ນ componentWillMount )
  • ພວກເຂົາພຽງແຕ່ກໍານົດວິທີການ render ແລະບໍ່ມີຫຍັງອີກ.

ເມື່ອອົງປະກອບຕິດຕາມມາຂ້າງເທິງ, ພວກເຮົາສາມາດກໍານົດມັນເປັນຫນ້າທີ່, ແທນທີ່ຈະໃຊ້ ການກະທໍາ. app class (or ) ສ້າງ App ປະຕິກິລິຢາ React Component ຖ້າທ່ານໃຊ້ ES2015 classes). ຕົວຢ່າງ, ການສະແດງທັງສອງຂ້າງລຸ່ມນີ້ຜະລິດສ່ວນດຽວກັນ:

  var App = React createClass ({render: function    {ກັບຄືນ  

ຊື່ຂອງຂ້າພະເຈົ້າແມ່ນ {ນີ້. props ຊື່}

}})var App = function (props) {ກັບຄືນ

ຂ້ອຍຊື່ {props. ຊື່}

}

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

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

ການຍອມຮັບຄຸນສົມບັດຫຼາຍ

ອົງປະກອບ ຄາດວ່າສອງຄຸນສົມບັດ:

  • ນີ້. props ກັບ , ທີ່ເປັນ URL ການເຊື່ອມຕໍ່ຄວນຈະໃຊ້ເວລາຜູ້ໃຊ້ກັບ
  • ນີ້. props ເດັກນ້ອຍ , ເຊິ່ງແມ່ນຂໍ້ຄວາມສະແດງໃຫ້ແກ່ຜູ້ໃຊ້.

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

ການແຜ່ກະຈາຍຂອງ JSX

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

  var props = {a: 1, b: 2}    

ການໃຊ້ {. ທີ່ຢູ່ ທີ່ຢູ່ props} ຈະແຜ່ລ້ໍາແຕ່ລະຈຸດສໍາຄັນໃນວັດຖຸແລະສົ່ງໃຫ້ Foo ເປັນຊັບສິນສ່ວນບຸກຄົນ.

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

  var AppLink = function (props) {return ;}    

ຕອນນີ້ ຈະຍອມຮັບຄຸນສົມບັດໃດໆແລະສົ່ງໃຫ້ພວກເຂົາຜ່ານ. ໃຫ້ສັງເກດວ່າພວກເຮົາຍັງສາມາດໃຊ້ແບບຟອມປິດຕົວເອງແທນທີ່ຈະອ້າງອີງຢ່າງຊັດເຈນ {props. ເດັກນ້ອຍ} ຢູ່ລະຫວ່າງ tags. React ຊ່ວຍໃຫ້ເດັກ ສາມາດຖ່າຍທອດໃຫ້ເປັນຜູ້ປົກກະຕິຫຼືເປັນເດັກນ້ອຍຂອງອົງປະກອບລະຫວ່າງປ້າຍເປີດແລະປິດ.

ທ່ານສາມາດເບິ່ງການເຮັດວຽກເທິງ Plunker.

ການສັ່ງຊື້ສິນຊັບໃນ React

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

   ການເຊື່ອມຕໍ່ລັບພິເສດ     

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

  return ;    

ເມື່ອທ່ານມີຊັບສົມບັດດຽວກັນຫຼາຍຄັ້ງໃນປະຕິກິລິຍາສ່ວນຫນຶ່ງ, ການປະກາດຫຼ້າສຸດ ໄດ້ຊະນະ . ນີ້ຫມາຍຄວາມວ່າຄໍາສັ່ງ activeClassName = "active-link" ສຸດທ້າຍຂອງພວກເຮົາຈະຊະນະເພາະວ່າມັນຖືກຈັດໃສ່ໃນ ຫຼັງຈາກ {. ທີ່ຢູ່ ທີ່ຢູ່ ນີ້. props} ເພື່ອແກ້ໄຂບັນຫານີ້, ພວກເຮົາສາມາດຈັດການກັບຊັບສິນດັ່ງນັ້ນພວກເຮົາຈະແຜ່ຂະຫຍາຍ ນີ້. props ສຸດທ້າຍ. ນີ້ຫມາຍຄວາມວ່າພວກເຮົາກໍານົດຄ່າເລີ່ມຕົ້ນທີ່ເຫມາະສົມທີ່ພວກເຮົາຕ້ອງການໃຊ້, ແຕ່ຜູ້ໃຊ້ສາມາດ override ພວກເຂົາຖ້າພວກເຂົາຕ້ອງການ:

  ກັບຄືນ     

ອີກເທື່ອຫນຶ່ງ, ທ່ານສາມາດເຫັນການປ່ຽນແປງໃນການປະຕິບັດໃນ Plunker.

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

ຜູ້ຜະລິດອະເນກປະສົງສູງ

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

ຈົ່ງ imagine ໃນຄໍາຮ້ອງສະຫມັກຂອງທ່ານວ່າທ່ານມີຈຸດປະສົງທີ່ມີຂໍ້ມູນກ່ຽວກັບຜູ້ໃຊ້ປັດຈຸບັນທີ່ຖືກກວດສອບໃນລະບົບ.

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

ສຽງທີ່ສັບສົນທີ່ສຸດ, ແຕ່ມັນໄດ້ງ່າຍຂຶ້ນໂດຍມີລະຫັດບາງ:

  function wrapWithUser (Component) {// ຂໍ້ມູນທີ່ພວກເຮົາບໍ່ຕ້ອງການເພື່ອເຂົ້າເຖິງທຸກໆຢ່າງvar secretUserInfo = {ຊື່: Jack Franklin,favouriteColour: 'ສີຟ້າ'}// ຄືນອົງປະກອບ React ສ້າງໃຫມ່// ການນໍາໃຊ້ອົງປະກອບທີ່ເປັນປະໂຫຍດ, ທີ່ບໍ່ມີປະໂຫຍດreturn function (props) {// ຜ່ານການປ່ຽນແປງຂອງຜູ້ໃຊ້ເປັນຊັບສິນ, ພ້ອມກັບ// ທຸກໆແບບອື່ນໆທີ່ພວກເຮົາອາດຈະໄດ້ຮັບreturn }}    

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

ຕອນນີ້ໃຫ້ເອົາສ່ວນປະກອບ , ເຊິ່ງຕ້ອງການການເຂົ້າເຖິງຂໍ້ມູນນີ້ເພື່ອໃຫ້ມັນສາມາດສະແດງຜູ້ໃຊ້ເຂົ້າສູ່ລະບົບ

  var AppHeader = function (props) {ຖ້າ (ຕົວຜູ້ໃຊ້) {ກັບ  

ເຂົ້າສູ່ລະບົບເປັນ {props. ຜູ້ໃຊ້. ຊື່}

} else {ກັບ

ທ່ານຈໍາເປັນຕ້ອງເຂົ້າສູ່ລະບົບ

;}}

ຂັ້ນຕອນສຸດທ້າຍແມ່ນການເຊື່ອມຕໍ່ອົງປະກອບນີ້ຂຶ້ນເພື່ອໃຫ້ມັນຖືກມອບໃຫ້ ນີ້. props ຜູ້ໃຊ້ . ພວກເຮົາສາມາດສ້າງອົງປະກອບໃຫມ່ໂດຍການສົ່ງຂໍ້ຄວາມນີ້ໄປສູ່ wrapWithUser ຂອງພວກເຮົາ.

  var ConnectedAppHeader = wrapWithUser (AppHeader)    

ຕອນນີ້ພວກເຮົາມີສ່ວນປະກອບ ທີ່ສາມາດສະແດງແລະຈະສາມາດເຂົ້າເຖິງ ຜູ້ໃຊ້ .

ເບິ່ງຕົວຢ່າງນີ້ໃນ Semalt ຖ້າທ່ານຢາກເຫັນມັນຢູ່ໃນປະຕິບັດ.

ຂ້າພະເຈົ້າໄດ້ເລືອກທີ່ຈະໂທຫາສ່ວນປະກອບ ConnectedAppHeader ເພາະວ່າຂ້ອຍຄິດວ່າມັນຖືກເຊື່ອມຕໍ່ກັບບາງຂໍ້ມູນພິເສດທີ່ບໍ່ໄດ້ຮັບການເຂົ້າເຖິງທຸກໆອົງປະກອບ.

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

ສະຫຼຸບ

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

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

ຖ້າທ່ານມີຄໍາຖາມໃດໆ, ຂ້າພະເຈົ້າຢາກຈະຟັງເຂົາເຈົ້າ. ມີຄວາມຮູ້ສຶກທີ່ຈະອອກຄໍາຄິດເຫັນຫຼື ping ຂ້າພະເຈົ້າ @Jack_Franklin ໃນ Twitter.

ພວກເຮົາໄດ້ຮ່ວມມືກັບ Open SourceCraft ເພື່ອເອົາມາໃຫ້ທ່ານ 6 ຄໍາແນະນໍາຈາກນັກພັດທະນາ React . ສໍາລັບເນື້ອຫາແຫຼ່ງເປີດຫຼາຍ, ໃຫ້ກວດເບິ່ງ Open SourceCraft.