Ask a question

Recent Questions

Categories

← Back to Question Center
0

ວິທີການຈັດຕັ້ງປະຕິບັດການປະຕິກິລິຍາຂະຫນາດໃຫຍ່ແລະເຮັດໃຫ້ມັນຂະຫຍາຍຕົວ            ວິທີການຈັດຕັ້ງປະຕິບັດຄໍາຮ້ອງສະຫມັກປະຕິກິລິຍາທີ່ມີຂະຫນາດໃຫຍ່ແລະເຮັດໃຫ້ມັນມີຄວາມຫຍຸ້ງຍາກຫົວຂໍ້: npmES6NodejsTools & Semalt

March 1, 2018
1 answers:
ວິທີການຈັດຕັ້ງປະຕິກິລິຍາການຕິກິຣິຍາຂະຫນາດໃຫຍ່ແລະເຮັດໃຫ້ມັນຂະຫຍາຍ

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

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

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

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

ວິທີການຈັດຕັ້ງປະຕິບັດການປະຕິກິລິຍາຂະຫນາດໃຫຍ່ແລະເຮັດໃຫ້ມັນຂະຫຍາຍຕົວວິທີການຈັດຕັ້ງປະຕິບັດຄໍາຮ້ອງສະຫມັກປະຕິກິລິຍາທີ່ມີຂະຫນາດໃຫຍ່ແລະເຮັດໃຫ້ມັນມີຄວາມຫຍຸ້ງຍາກຫົວຂໍ້: npmES6Node jsTools & Semalt

ເຄື່ອງມືສ້າງແລະສີຂີ້ເຖົ່າ

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

ຂ້າພະເຈົ້າຍັງໃຊ້ syntax ໂມດູນ ES2015 (ຊຶ່ງຈະຖືກສົ່ງຜ່ານ Babel) ເພື່ອນໍາເຂົ້າແລະສົ່ງອອກທີ່ກ່ຽວຂ້ອງ. ການແປພາສານີ້ມີປະມານສໍາລັບເວລາໃນຂະນະນີ້, ແລະເຖິງແມ່ນວ່າ Webpack ສາມາດສະຫນັບສະຫນູນ CommonJS (aka, Node-style imports), ມັນເຮັດໃຫ້ຂ້ອຍຮູ້ສຶກເລີ່ມຕົ້ນໃນການໃຊ້ໃຫມ່ແລະຍິ່ງໃຫຍ່ທີ່ສຸດ. ນອກຈາກນີ້, Webpack ສາມາດລຶບລະຫັດທີ່ບໍ່ຖືກຕ້ອງຈາກມັດດ້ວຍ ES2015 ຊຶ່ງບໍ່ສົມບູນ, ມັນເປັນສິ່ງທີ່ມີປະໂຫຍດຫລາຍທີ່ຈະມີແລະຈະເປັນປະໂຫຍດຕໍ່ກັບຊຸມຊົນຕໍ່ກັບການເຜີຍແຜ່ລະຫັດເຖິງ npm ໃນ ES2015.

ກໍານົດການແກ້ໄຂໂປຼແກຼມ ຂອງ Webpack ເພື່ອຫຼີກລ້ຽງການນໍາເຂົ້າທີ່ຖືກຕ້ອງ

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

  import foo ຈາກ ' / foo 'ແຖບນໍາເຂົ້າຈາກ '. ທີ່ຢູ່ / ທີ່ຢູ່ / ທີ່ຢູ່ / bar 'ນໍາເຂົ້າຈາກ '. ທີ່ຢູ່ / ທີ່ຢູ່ / lib / baz '

ເມື່ອທ່ານກໍາລັງສ້າງແອັບຯຂອງທ່ານກັບ Webpack ທ່ານສາມາດບອກ Webpack ໃຫ້ຊອກຫາຢູ່ໃນໄດເລກະທໍລີສະເພາະໃດຫນຶ່ງສໍາລັບໄຟລ໌ຖ້າມັນບໍ່ສາມາດຊອກຫາມັນໄດ້ເຊິ່ງທ່ານສາມາດກໍານົດໂຟເດີພື້ນຖານທີ່ທັງຫມົດຂອງທ່ານສາມາດນໍາໃຊ້ໄດ້ ທີ່ຢູ່ ຂ້ອຍສະເຫມີໃສ່ລະຫັດຂອງຂ້ອຍໃນໄດເລກະທໍລີ src . ຂ້ອຍສາມາດບອກ Webpack ໃຫ້ຊອກຫາຢູ່ໃນໄດເລກະທໍລີນັ້ນ. ນີ້ແມ່ນຍັງບ່ອນທີ່ທ່ານຕ້ອງບອກ Webpack ກ່ຽວກັບການຂະຫຍາຍໄຟລ໌ອື່ນໆທີ່ທ່ານອາດຈະໃຊ້ເຊັ່ນ: . jsx : 

  // inside Webpack config object{ແກ້ໄຂ: {modules: ['node_modules', 'src'],extensions: ['. js ',' jsx '],}}

ຄ່າເລີ່ມຕົ້ນສໍາລັບ ແກ້ໄຂ.

ເມື່ອທ່ານເຮັດແລ້ວທ່ານສາມາດນໍາເຂົ້າໄຟລ໌ທີ່ກ່ຽວຂ້ອງກັບໄດເລກະທໍລີ src : 

  import foo ຈາກ ' / foo 'ນໍາເຂົ້າແຖບຈາກ 'app / bar' // => src / app / barimport baz ຈາກ 'an / example / import' // => src / an / example / import

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

ໂຄງສ້າງໂຟເດີ

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

Code lives in src

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

  - src => ລະຫັດ app ທີ່ນີ້- webpack => webpack configs- scripts => any build scripts- tests => ລະຫັດການທົດສອບໃດໆ (API mocks, etc)

ໂດຍປົກກະຕິ, ໄຟລ໌ພຽງແຕ່ຈະຢູ່ໃນລະດັບເທິງແມ່ນ ດັດຊະນີ. html , ຊຸດ json , ແລະເອກະສານສະເພາະໃດຫນຶ່ງ, ເຊັ່ນ . babelrc ບາງຄົນມັກຈະປະກອບມີການຕັ້ງຄ່າ Babel ໃນ ຊຸດ. json , ແຕ່ຂ້າພະເຈົ້າຊອກຫາໄຟລ໌ເຫຼົ່ານີ້ສາມາດໄດ້ຮັບການຂະຫນາດໃຫຍ່ໃນໂຄງການໃຫຍ່ທີ່ມີຄວາມຕ້ອງການຫຼາຍ, ດັ່ງນັ້ນຂ້າພະເຈົ້າຢາກໃຊ້ . eslintrc , babelrc , ແລະອື່ນໆ.

ໂດຍການຮັກສາລະຫັດ app ຂອງທ່ານໃນ src , ທ່ານຍັງສາມາດໃຊ້ການແກ້ໄຂ . ໂມດູນ trick ຂ້າພະເຈົ້າໄດ້ກ່າວມາກ່ອນຫນ້ານີ້, ເຊິ່ງງ່າຍດາຍການນໍາເຂົ້າທັງຫມົດ.

ອົງປະກອບຂອງປະຕິກິລິຍາ

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

ແນວໂນ້ມທົ່ວໄປແມ່ນມີແຟ້ມສໍາລັບສ່ວນປະກອບ "smart" ແລະ "dumb" (ເຊິ່ງເອີ້ນວ່າ "ອຸປະກອນ" ແລະ "ປະຈຸບັນ") ແຕ່ສ່ວນຕົວຂ້ອຍບໍ່ເຄີຍພົບແຟ້ມທີ່ຊັດເຈນເຮັດວຽກສໍາລັບຂ້ອຍ. ໃນຂະນະທີ່ຂ້າພະເຈົ້າມີສ່ວນປະກອບທີ່ແບ່ງອອກຢ່າງວ່ອງໄວໃນ "smart" ແລະ "dumb" (Semalt ສົນທະນາກ່ຽວກັບດ້ານລຸ່ມນີ້), ຂ້ອຍບໍ່ມີໂຟນເດີທີ່ແນ່ນອນສໍາລັບແຕ່ລະຄົນ.

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

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

  ນໍາເຂົ້າທັງຫມົດຈາກ 'src / cart / total'// vsນໍາເຂົ້າ CartTotal ຈາກ 'src / cart / cart-total'

ນີ້ແມ່ນກົດລະບຽບທີ່ຂ້າພະເຈົ້າເຫັນວ່າຕົວເອງຖືກທໍາລາຍບາງຄັ້ງ: ຄໍາແນະນໍາພິເສດສາມາດອະທິບາຍໄດ້ໂດຍສະເພາະຖ້າທ່ານມີ 2-3 ອົງປະກອບຊື່ທີ່ຄ້າຍຄືກັນແຕ່ມັກວິທີນີ້ສາມາດຫຼີກເວັ້ນການຊ້ໍາຊ້ໍາຂອງຊື່. ດັ່ງນັ້ນໃນການນໍາເຂົ້າຂ້າງເທິງ, ໄຟລ໌ຈະເປັນ CartTotal. js , ຫຼື ລວມ. js ຂ້າພະເຈົ້າມັກຈະມັກຕິດກັບໄຟລ໌ຕ່ໍາທີ່ມີ dashes ເປັນແຍກ, ດັ່ງນັ້ນເພື່ອແນໃສ່ຂ້າພະເຈົ້າໃຊ້ . jsx extension for React components ເພາະສະນັ້ນ, ຂ້າພະເຈົ້າຕ້ອງຕິດກັບ ໂຄງຮ່າງການທັງຫມົດ. jsx

ນີ້ມີຜົນປະໂຫຍດເລັກນ້ອຍທີ່ສາມາດຊອກຫາໄດ້ງ່າຍໂດຍຜ່ານໄຟລ໌ React ຂອງທ່ານໂດຍການຈໍາກັດການຊອກຫາຂອງທ່ານກັບໄຟລ໌ທີ່ມີ . jsx , ແລະທ່ານກໍ່ສາມາດນໍາໃຊ້ໂປແກຼມ Webpack ສະເພາະກັບໄຟລ໌ເຫຼົ່ານີ້ຖ້າທ່ານຕ້ອງການ.

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

ອົງປະກອບຫນຶ່ງໃນການຕອບສະຫນອງຕໍ່ໄຟລ໌

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

ໂດຍປົກກະຕິໄຟລ໌ Semalt ຂອງພວກເຮົາຄື: 

  import React, {Component, PropTypes} ຈາກ 'react'export default class Total extends Component {.}

ໃນກໍລະນີທີ່ເຮົາຕ້ອງລວບລວມອົງປະກອບເພື່ອເຊື່ອມຕໍ່ມັນກັບຮ້ານຂໍ້ມູນ Semalt, ສໍາລັບຕົວຢ່າງ, ອົງປະກອບທີ່ຖືກຫຸ້ມຢ່າງເຕັມທີ່ຈະກາຍເປັນການສົ່ງອອກໂດຍ Default: 

  import React, {Component, PropTypes} ຈາກ 'react'import {connect} ຈາກ 'react-redux'ຊັ້ນສົ່ງອອກທັງຫມົດຂະຫຍາຍສ່ວນປະກອບ {.}export default (  ) => {}) (Total)

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

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

"ຄອມພິວເຕີ້" ແລະ "ຄອມພິວເຕີ້" ປະຕິກິລິຢາສ່ວນປະກອບ

ຂ້າພະເຈົ້າໄດ້ກ່າວເຖິງໄລຍະຫ່າງຂອງອົງປະກອບ "smart" ແລະ "dumb", ແລະນັ້ນແມ່ນສິ່ງທີ່ພວກເຮົາປະຕິບັດໃນຖານຂໍ້ມູນຂອງພວກເຮົາ. Semalt ພວກເຮົາບໍ່ໄດ້ຮັບຮູ້ມັນໂດຍແບ່ງອອກເປັນແຟ້ມ, ທ່ານສາມາດແບ່ງປັນ app ຂອງພວກເຮົາເປັນປະເພດສອງປະເພດ:

  • ອົງປະກອບ "smart" ທີ່ຈັດການຂໍ້ມູນ, ເຊື່ອມຕໍ່ກັບ Redux, ແລະການໂຕ້ຕອບກັບຜູ້ໃຊ້
  • ອົງປະກອບ "dumb" ທີ່ໄດ້ຮັບການຕັ້ງຊຸດແລະນໍາຂໍ້ມູນບາງຢ່າງໄປຍັງຫນ້າຈໍ.

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

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

ຫຼີກເວັ້ນການຂະຫນາດໃຫຍ່ render ວິທີການ

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

ສະເຫມີໃຊ້ prop-type

Semalt ອະນຸຍາດໃຫ້ທ່ານເຮັດເປັນເອກະສານຊື່ແລະປະເພດຂອງຄຸນສົມບັດທີ່ທ່ານຄາດຫວັງໃຫ້ສະມາຊິກໄດ້ຮັບໂດຍໃຊ້ຊຸດປະເພດ prop-types ຂອງຕົນ. ໃຫ້ສັງເກດວ່ານີ້ໄດ້ປ່ຽນແປງເປັນ Semalt 15 5. ກ່ອນຫນ້ານີ້, ໂປແກຣມໂປແກຼມແມ່ນສ່ວນຫນຶ່ງຂອງ Semalt module.

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

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

Redux

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

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

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

  ducks- ດັດນີ. js- ຜູ້ໃຊ້. js- ໂພດ. js

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

  // user jsconst LOG_IN = 'LOG_IN'export const logIn = name => ({type: LOG_IN, name})export default function reducer (state = {}, action) {.}

ນີ້ຊ່ວຍປະຢັດທ່ານທີ່ຈະນໍາເຂົ້າການປະຕິບັດແລະການສ້າງກິດຈະກໍາຕ່າງໆຈາກໄຟລ໌ຕ່າງໆແລະຮັກສາລະຫັດສໍາລັບພາກສ່ວນຕ່າງໆຂອງຮ້ານຂອງທ່ານຕໍ່ກັບກັນ.

ໂມດູນ JavaScript Stand-alone

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

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

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

  // ບໍລິການ / ການເກັບຮັກສາທ້ອງຖິ່ນ. jsconst LocalStorage = {get    {},set    {},.}ສົ່ງອອກທ້ອງຖິ່ນ DefaultStorage

ສົມເຫດສົມຜົນຂອງທ່ານອອກຈາກສ່ວນປະກອບດັ່ງກ່າວນີ້ມີຜົນປະໂຫຍດທີ່ຍິ່ງໃຫຍ່ບາງຢ່າງ:

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

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

      import Foo from ' ທີ່ຢູ່ / ທີ່ຢູ່ / ທີ່ຢູ່ / src / app / foo '

    Semalt ມີຄວາມຫຍຸ້ງຍາກໃນການເຮັດວຽກແລະມີຄວາມຫຍຸ້ງຍາກໃນການແກ້ໄຂຖ້າທ່ານປ່ຽນໂຄງສ້າງຂອງໄດເລກະທໍລີ.

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

      - ລົດເຂັນ- ທັງຫມົດ. jsx- ທັງຫມົດ. spec jsx- ບໍລິການ- ການເກັບຮັກສາໃນທ້ອງຖິ່ນ. js- ການເກັບຮັກສາໃນທ້ອງຖິ່ນ. spec js

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

    ສະຫຼຸບ

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

    ວິທີການຈັດຕັ້ງປະຕິບັດການປະຕິກິລິຍາຂະຫນາດໃຫຍ່ແລະເຮັດໃຫ້ມັນຂະຫຍາຍຕົວວິທີການຈັດຕັ້ງປະຕິບັດຄໍາຮ້ອງສະຫມັກປະຕິກິລິຍາທີ່ມີຂະຫນາດໃຫຍ່ແລະເຮັດໃຫ້ມັນມີຄວາມຫຍຸ້ງຍາກຫົວຂໍ້: npmES6Node jsTools & Semalt
    ພົບຜູ້ຂຽນ
    Jack Franklin
    ຂ້ອຍເປັນນັກພັດທະນາ JavaScript ແລະ Ruby ທີ່ເຮັດວຽກຢູ່ລອນດອນໂດຍສຸມໃສ່ເຄື່ອງມື ES2015 ແລະ ReactJS.
ວິທີການຈັດຕັ້ງປະຕິບັດການປະຕິກິລິຍາຂະຫນາດໃຫຍ່ແລະເຮັດໃຫ້ມັນຂະຫຍາຍຕົວວິທີການຈັດຕັ້ງປະຕິບັດຄໍາຮ້ອງສະຫມັກປະຕິກິລິຍາທີ່ມີຂະຫນາດໃຫຍ່ແລະເຮັດໃຫ້ມັນມີຄວາມຫຍຸ້ງຍາກຫົວຂໍ້: npmES6Node jsTools & Semalt
ວິທີທີ່ດີທີ່ສຸດທີ່ຈະຮຽນຮູ້ສໍາລັບຜູ້ເລີ່ມໃຫມ່
Wes Bos
ຫຼັກສູດການຝຶກອົບຮົມຂັ້ນຕອນໂດຍຂັ້ນຕອນເພື່ອໃຫ້ທ່ານສ້າງໂລກຕິກິຣິຍາທີ່ແທ້ຈິງ. js + Firebase apps ແລະອົງປະກອບເວັບໄຊທ໌ໃນສອງສາມຕອນແລງ. ໃຊ້ລະຫັດຄູປອງ 'SITEPOINT' ທີ່ເຊັກເອົາເພື່ອຮັບ 25% Source .
March 1, 2018