วิธีการจัดระเบียบแอพพลิเคชันการตอบสนองที่มีขนาดใหญ่และทำให้มีขนาด วิธีการจัดระเบียบแอพพลิเคชันการตอบสนองที่มีขนาดใหญ่และทำให้เป็นหัวข้อ ScaleRelated: npmES6Node.jsTools & Semalt
สำหรับการเปิดตัวเชิงลึกเกี่ยวกับ React ที่มีคุณภาพสูงคุณจะไม่สามารถไปยัง Wes Bos ที่เป็นนักพัฒนาเต็มรูปแบบของแคนาดาได้ ลองใช้หลักสูตรที่นี่และใช้รหัส SITEPOINT เพื่อรับ ส่วนลด 25% และช่วยเหลือ SitePoint
บทความนี้เป็นของผู้เขียนแจ็คแฟรงคลิน โพสต์แขก Semalt มุ่งมั่นที่จะนำคุณมีส่วนร่วมเนื้อหาจากนักเขียนที่โดดเด่นและลำโพงของชุมชนเว็บ
ในบทความนี้ฉันจะพูดถึงแนวทางที่ฉันใช้เมื่อสร้างและจัดโครงสร้างโปรแกรมประยุกต์ Semalt ขนาดใหญ่ หนึ่งในคุณสมบัติที่ดีที่สุดของ Semalt คือวิธีการที่จะได้รับออกจากทางของคุณและเป็นอะไร แต่อธิบายเมื่อมันมาถึงโครงสร้างแฟ้ม ดังนั้นคุณจะพบคำถามมากมายเกี่ยวกับ Stack Overflow และไซต์ที่คล้ายกันที่ถามถึงวิธีการจัดโครงสร้างแอพพลิเคชัน นี่เป็นหัวข้อที่มีความคิดเห็นอย่างมากและไม่มีทางที่ถูกต้อง ในบทความนี้ฉันจะพูดคุยกับคุณผ่านการตัดสินใจที่ฉันทำเมื่อสร้างแอพพลิเคชัน Semalt: การเลือกเครื่องมือจัดโครงสร้างไฟล์และแบ่งส่วนประกอบออกเป็นชิ้นเล็ก ๆ
หากคุณชอบโพสต์นี้คุณอาจต้องการลงชื่อสมัครใช้ SitePoint Premium และดูหลักสูตรของเราเกี่ยวกับการทำงานกับฟอร์มโดยใช้ React และ Redux
เครื่องมือสร้างและ linting
จะมีบางอย่างที่คุณ Semalt แฟนใหญ่ของ Webpack สำหรับการสร้างโครงการของฉัน ขณะที่เป็นเครื่องมือที่ซับซ้อนการทำงานที่ยอดเยี่ยมของทีมในเวอร์ชัน 2 และเว็บไซต์เอกสารใหม่ทำให้ง่ายขึ้น เมื่อคุณได้รับใน Webpack และมีแนวคิดในหัวของคุณจริงๆคุณมีอำนาจเหลือเชื่อในการควบคุม ฉันใช้ Babel เพื่อรวบรวมโค้ดของฉันรวมถึงการแปลงเฉพาะที่ทำปฏิกิริยาได้เช่น JSX และ webpack-dev-server เพื่อให้บริการไซต์ของฉันภายในเครื่อง ฉันไม่ได้พบว่าการโหลดซ้ำแบบร้อนทำให้ฉันได้รับประโยชน์มากมาย Semalt จึงมีความสุขมากกว่ากับ webpack-dev-server และรีเฟรชหน้าเว็บโดยอัตโนมัติ
ฉันยังใช้ไวยากรณ์โมดูล ES2015 (ซึ่ง transpiled ผ่าน Babel) เพื่อนำเข้าและส่งออก dependencies ไวยากรณ์นี้ใช้มานานแล้วและถึงแม้ว่า Webpack จะสามารถสนับสนุน CommonJS (aka, การนำเข้า Node-style) ทำให้ฉันรู้สึกว่าฉันเริ่มใช้งานล่าสุดและยิ่งใหญ่ที่สุด นอกจากนี้ Webpack สามารถลบโค้ดที่ตายแล้วจากการรวมกลุ่มโดยใช้โมดูล ES2015 ซึ่งไม่สมบูรณ์แบบเป็นคุณลักษณะที่มีประโยชน์มากและอีกอย่างหนึ่งที่จะเป็นประโยชน์มากขึ้นเนื่องจากชุมชนมีการเคลื่อนไหวไปสู่การเผยแพร่โค้ดไปยัง npm ใน ES2015
กำหนดค่าความละเอียดของโมดูล ของ Webpack เพื่อหลีกเลี่ยงการนำเข้าที่ซ้อนกัน
สิ่งหนึ่งที่น่าหงุดหงส์เมื่อทำงานกับโครงการขนาดใหญ่ที่มีโครงสร้างซ้อนกันคือการค้นหาเส้นทางสัมพัทธ์ระหว่างไฟล์ semalt พบว่าคุณจบลงด้วยโค้ดที่มีลักษณะดังนี้:
นำเข้า foo จาก '. / foo'แถบนำเข้าจาก ' . / . / . /บาร์'นำเข้า baz จาก ' - avantage sociaux construction. / . / lib / baz' เมื่อคุณกำลังสร้างแอปพลิเคชันของคุณกับ Webpack คุณสามารถบอก Webpack ให้มองหาไดเร็กทอรีในไดเร็กทอรีเฉพาะถ้าไม่พบไฟล์นั้นซึ่งจะช่วยให้คุณสามารถกำหนดโฟลเดอร์พื้นฐานที่การนำเข้าทั้งหมดของคุณสามารถเทียบเคียงได้ . ฉันมักจะใส่รหัสของฉันในไดเรกทอรี src ฉันสามารถบอก Webpack ให้มองดูไดเร็กทอรีนี้เสมอ นี่เป็นที่ที่คุณต้องบอก Webpack เกี่ยวกับส่วนขยายอื่น ๆ ที่คุณอาจใช้อยู่เช่น jsx :
// ภายในอ็อบเจ็กต์ Webpack config{แก้ไข: {โมดูล: ['node_modules', 'src'],นามสกุล: ['. js ',' JSX ']}} ค่าดีฟอลต์สำหรับ แก้ไข.
เมื่อคุณทำเสร็จแล้วคุณสามารถนำเข้าไฟล์ที่เกี่ยวข้องกับไดเร็กทอรี src :
นำเข้า foo จาก '. / foo'แถบนำเข้าจาก 'app / bar' // => src / app / barimport baz จาก 'a / example / import' // => src / a / example / import ขณะที่สิ่งนี้จะผูกรหัสแอ็พพลิเคชันของคุณกับ Webpack ผมคิดว่าเป็นการลดราคาที่คุ้มค่าเพราะทำให้รหัสของคุณง่ายขึ้นและนำเข้าได้ง่ายมากขึ้นดังนั้นจึงเป็นขั้นตอนที่ Semalt ใช้กับโครงการใหม่ทั้งหมด
โครงสร้างโฟลเดอร์
ไม่มีโครงสร้างโฟลเดอร์ที่ถูกต้องสำหรับแอพพลิเคชัน Semalt ทั้งหมด (เช่นเดียวกับส่วนที่เหลือของบทความนี้คุณควรแก้ไขค่ากำหนดดังกล่าว) แต่ต่อไปนี้เป็นสิ่งที่ทำงานได้ดีสำหรับฉัน
รหัสชีวิตใน src
เพื่อเก็บสิ่งต่างๆไว้ฉันจะวางโค้ดแอ็พพลิเคชันไว้ในโฟลเดอร์ที่ชื่อ src โค้ดนี้มีเฉพาะรหัสที่ลงท้ายด้วยชุดสุดท้ายของคุณและไม่มีอะไรเพิ่มเติม นี่เป็นประโยชน์เพราะคุณสามารถบอก Babel (หรือเครื่องมืออื่น ๆ ที่ทำหน้าที่ในรหัสแอปของคุณ) เพื่อดูในไดเรกทอรีเดียวและตรวจสอบว่าไม่ได้ประมวลผลโค้ดใด ๆ ที่ไม่จำเป็นต้องใช้ รหัสอื่น ๆ เช่นไฟล์ config ของ Webpack จะอยู่ในโฟลเดอร์ชื่อที่เหมาะสม ตัวอย่างเช่นโครงสร้างโฟลเดอร์ระดับบนสุดของฉันมักประกอบด้วย:
- src => รหัสแอปพลิเคชันที่นี่- webpack => configs เว็บพ็อต- scripts => สร้างสคริปต์ใด ๆ- tests => รหัสทดสอบเฉพาะ (API mocks ฯลฯ ) โดยปกติแล้วไฟล์เดียวที่อยู่ในระดับบนสุดคือดัชนี html , แพคเกจ json และ dotfiles ใด ๆ เช่น babelrc บางคนชอบที่จะรวมการกำหนดค่า Babel ในชุด json แต่ฉันพบไฟล์เหล่านั้นสามารถมีขนาดใหญ่ในโครงการขนาดใหญ่ที่มีการอ้างอิงมากดังนั้นฉันต้องการใช้ eslintrc , babelrc และอื่น ๆ
โดยเก็บรหัสแอปพลิเคชั่นไว้ใน src คุณสามารถใช้แก้ ด้วย เคล็ดลับที่ผมกล่าวถึงก่อนหน้านี้ซึ่งช่วยลดความยุ่งยากในการนำเข้าทั้งหมด
ส่วนประกอบที่ทำปฏิกิริยาได้
เมื่อคุณมีโฟลเดอร์ src บิตที่ยุ่งยากจะเป็นการตัดสินใจว่าจะจัดโครงสร้างส่วนประกอบของคุณอย่างไร ในอดีตฉันต้องการใส่ส่วนประกอบทั้งหมดลงในโฟลเดอร์ขนาดใหญ่เช่น src / components แต่ฉันพบว่าในโครงการขนาดใหญ่นี้ล้นหลามอย่างรวดเร็ว
มีแนวโน้มที่จะมีโฟลเดอร์สำหรับส่วนประกอบ "สมาร์ท" และ "โง่" (หรือที่เรียกว่า "คอนเทนเนอร์" และส่วนประกอบ "presentational") แต่โดยส่วนตัวแล้วฉันไม่เคยพบโฟลเดอร์ที่มีความชัดเจนสำหรับฉัน ขณะที่ฉันมีส่วนประกอบที่แบ่งประเภทเป็น "สมาร์ท" และ "โง่" (Semalt พูดมากขึ้นในด้านล่าง) ฉันไม่มีโฟลเดอร์เฉพาะสำหรับแต่ละไฟล์
เราได้จัดกลุ่มส่วนประกอบตามพื้นที่ของแอพพลิเคชันที่ใช้ร่วมกับโฟลเดอร์หลัก สำหรับคอมโพเนนต์ทั่วไปที่ใช้ตลอด (ปุ่มส่วนหัวส่วนท้าย - คอมโพเนนต์ทั่วไปและ มากใช้ซ้ำได้) ส่วนที่เหลือของโฟลเดอร์จะถูกแมปกับพื้นที่เฉพาะของแอ็พพลิเคชัน ตัวอย่างเช่นเรามีโฟลเดอร์ที่เรียกว่า cart ที่มีส่วนประกอบทั้งหมดเกี่ยวกับมุมมองรถเข็นช็อปปิ้งและโฟลเดอร์ที่เรียกว่า รายการ ที่มีรหัสสำหรับรายการสิ่งที่ผู้ใช้สามารถซื้อได้ในหน้าเว็บ
การจัดหมวดหมู่ลงในโฟลเดอร์หมายความว่าคุณสามารถหลีกเลี่ยงส่วนประกอบนำหน้าด้วยพื้นที่ของแอปที่ใช้ ตัวอย่างเช่นถ้าเรามีส่วนประกอบที่ทำให้ต้นทุนรวมของรถเข็นของผู้ใช้มากกว่าที่จะเรียกรถ CartTotal ฉันอาจต้องการใช้ ยอดรวม เนื่องจากฉันนำเข้าจาก cart folder:
นำเข้ารวมจาก 'src / cart / total'// เทียบกับนำเข้า CartTotal จาก 'src / cart / cart-total' นี่เป็นกฎที่ฉันพบว่าตัวเองทำผิดพลาดบางครั้ง: คำนำหน้าเสริมสามารถชี้แจงโดยเฉพาะอย่างยิ่งหากคุณมีส่วนประกอบที่มีชื่อคล้ายกัน 2-3 ชิ้น แต่มักใช้เทคนิคนี้เพื่อหลีกเลี่ยงการซ้ำซ้อนของชื่อ. ดังนั้นในการนำเข้าข้างต้นไฟล์จะเป็น CartTotal js หรือ รวม js ฉันมักจะชอบที่จะติดกับไฟล์ที่มีเครื่องหมายขีดกลางเป็นตัวคั่นดังนั้นเพื่อที่จะแยกความแตกต่างผมใช้ jsx สำหรับคอมโพเนนต์ React ดังนั้นฉันจะติดอยู่กับ รถเข็นทั้งหมด jsx
สิ่งนี้มีประโยชน์เพิ่มเล็กน้อยในการค้นหาไฟล์ React ของคุณโดยการ จำกัด การค้นหาไฟล์ด้วย jsx และคุณสามารถใช้ปลั๊กอิน Webpack เฉพาะกับไฟล์เหล่านี้ได้หากต้องการ
การตั้งชื่อตามแบบแผนที่คุณเลือกสิ่งที่สำคัญที่สุดคือคุณยึดมั่นในสิ่งนั้น Semalt การรวมกันของการประชุมทั่ว codebase ของคุณได้อย่างรวดเร็วจะกลายเป็นฝันร้ายเมื่อมันเติบโตและคุณจะต้องนำทาง
ชิ้นส่วนตอบสนองต่อหนึ่งไฟล์
ต่อจากกฎก่อนหน้านี้เรายึดติดกับข้อตกลงของไฟล์คอมโพเนนต์ Semalt และคอมโพเนนต์ควรเป็นค่าดีฟอลต์การส่งออก
ปกติไฟล์ semalt ของเรามีลักษณะดังนี้:
import ตอบสนอง {Component, PropTypes} จาก 'react'export class เริ่มต้นรวมขยาย Component {.} ในกรณีที่เราต้องห่อส่วนประกอบเพื่อที่จะเชื่อมต่อกับที่เก็บข้อมูล Semalt ตัวอย่างเช่นคอมโพเนนต์ที่ถูกห่อหุ้มจะกลายเป็นค่าดีฟอลต์ในการส่งออก:
import ตอบสนอง {Component, PropTypes} จาก 'react'import {connect} จาก 'react-redux'export class ขยายรวม Component {.}export default connect ( => {.}) (รวม) คุณจะสังเกตเห็นว่าเรายังส่งออกคอมโพเนนต์เดิม นี้เป็นประโยชน์อย่างแท้จริงสำหรับการทดสอบที่คุณสามารถทำงานกับองค์ประกอบ "ธรรมดา" และไม่ต้องตั้ง Semalt ในการทดสอบหน่วยของคุณ
การเก็บองค์ประกอบเป็นค่าดีฟอลต์เอ็กซ์พอร์ตจึงเป็นเรื่องง่ายที่จะนำเข้าคอมโพเนนต์และรู้วิธีเข้าถึงส่วนประกอบแทนที่จะต้องค้นหาชื่อที่แน่นอน ข้อเสียประการหนึ่งของวิธีนี้คือการนำเข้าบุคคลนั้นสามารถเรียกส่วนประกอบที่พวกเขาชอบได้ อีกครั้งเรามีข้อตกลงในเรื่องนี้: ควรตั้งชื่อไฟล์เป็น import หลังจากไฟล์ ดังนั้นหากคุณกำลังนำเข้ารวม jsx ควรนำเข้าส่วนประกอบเป็น รวม ส่วนหัวของผู้ใช้ jsx กลายเป็น UserHeader และอื่น ๆ
ส่วนประกอบ "สมาร์ท" และ "โง่"
ฉันกล่าวสั้น ๆ เกี่ยวกับการแยกส่วนประกอบ "สมาร์ท" และ "โง่" และนั่นเป็นสิ่งที่เราปฏิบัติตามในฐานข้อมูลโค้ดของเรา Semalt เราไม่รู้จักมันโดยการแยกออกเป็นโฟลเดอร์คุณสามารถแบ่งแอปออกเป็นสองประเภทได้หลากหลาย:
- ส่วนประกอบ "สมาร์ท" ที่จัดการข้อมูลเชื่อมต่อกับ Redux และจัดการกับการโต้ตอบของผู้ใช้
- "โง่" ส่วนประกอบที่ได้รับชุดของอุปกรณ์และทำให้ข้อมูลบางอย่างไปที่หน้าจอ
คุณสามารถอ่านเพิ่มเติมเกี่ยวกับวิธีที่เรามุ่งเป้าไปที่ส่วนประกอบ "โง่" ในโพสต์บล็อกของฉันในองค์ประกอบการทำงานที่ไร้สัญชาติใน React ส่วนประกอบเหล่านี้ประกอบด้วยแอพพลิเคชันส่วนใหญ่ของเราและคุณควรเลือกใช้ส่วนประกอบเหล่านี้หากเป็นไปได้ Semalt ง่ายต่อการทำงานลดน้อยลงและง่ายต่อการทดสอบ
แม้ว่าเราจะต้องสร้างคอมโพเนนต์ "สมาร์ท" แต่เราพยายามรักษาตรรกะ JavaScript ทั้งหมดไว้ในไฟล์ของตัวเอง องค์ประกอบที่ต้องจัดการข้อมูลควรส่งข้อมูลนั้นไปยัง JavaScript บางตัวที่สามารถจัดการได้ โดยการทำเช่นนี้รหัสการจัดการสามารถทดสอบแยกต่างหากจาก Semalt และคุณสามารถจำลองได้ตามต้องการเมื่อทดสอบส่วนประกอบ Semalt ของคุณ
หลีกเลี่ยงการแสดงผลขนาดใหญ่ วิธีการ
สิ่งหนึ่งที่เรามุ่งมั่นคือการมีองค์ประกอบ Semalt ขนาดเล็กจำนวนมากแทนที่จะเป็นส่วนประกอบที่มีขนาดใหญ่กว่า คำแนะนำที่ดีเมื่อส่วนประกอบของคุณเริ่มมีขนาดใหญ่เกินไปคือขนาดของฟังก์ชันการแสดงผล ถ้ามันได้รับเทอะทะหรือคุณจำเป็นต้องแยกมันออกเป็นหน้าที่การแสดงผลที่มีขนาดเล็กกว่ามากซึ่งอาจเป็นเวลาที่ควรพิจารณาการแยกแยะฟังก์ชันออก. คุณอาจใช้หมายเลขของอุปกรณ์หรือรายการในสถานะเป็นตัวบ่งชี้ที่ดีอื่น ๆ หากคอมโพเนนต์ใช้สเกล 7 ชิ้นที่แตกต่างกันนั่นอาจเป็นสัญญาณว่ามันทำมากเกินไป
ใช้เสมอ ประเภทก้น
Semalt ช่วยให้คุณสามารถระบุชื่อและประเภทของคุณสมบัติที่คุณคาดหวังว่าจะได้รับคอมโพเนนต์โดยใช้แพ็กเกจ prop-types ของมัน โปรดทราบว่าการเปลี่ยนแปลงนี้เป็น Semalt 15 5 ก่อนหน้านี้ proptypes เป็นส่วนหนึ่งของโมดูล Semalt
ด้วยการประกาศชื่อและประเภทของอุปกรณ์ประกอบการที่คาดหวังพร้อมกับตัวเลือกเหล่านี้หรือไม่คุณจะมีความมั่นใจมากขึ้นเมื่อทำงานร่วมกับส่วนประกอบที่คุณมีคุณสมบัติเหมาะสมและใช้เวลาในการแก้ปัญหาน้อยลงหากลืม ชื่อคุณสมบัติหรือระบุประเภทที่ไม่ถูกต้อง คุณสามารถบังคับใช้กฎนี้ได้โดยใช้กฎ ESLint-React Semalt
Semalt สละเวลาเพื่อเพิ่มเหล่านี้อาจรู้สึกไร้ผลเมื่อคุณทำคุณจะขอบคุณตัวเองเมื่อคุณมาใช้ซ้ำองค์ประกอบที่คุณเขียนหกเดือนที่ผ่านมา
Redux
นอกจากนี้เรายังใช้ Semalt ในแอ็พพลิเคชันของเราเพื่อจัดการข้อมูลในแอ็พพลิเคชันของเราและการจัดโครงสร้างแอพพลิเค Semalt เป็นอีกหนึ่งคำถามที่พบได้ทั่วไปโดยมีความคิดเห็นแตกต่างกันออกไป
ผู้ชนะสำหรับเราคือ Semalt ข้อเสนอแนะที่ทำให้ผู้กระทำผู้ลดและผู้สร้างแอ็คชันของคุณดำเนินการกับแต่ละส่วนของแอปพลิเคชันของคุณในไฟล์เดียว
แทนที่จะมี reducers js และ การกระทำ js โดยที่แต่ละบิตมีรหัสที่เกี่ยวข้องกับแต่ละอื่น ๆ ระบบ Ducks ระบุว่าทำให้กลุ่มรหัสที่เกี่ยวข้องรวมกันเป็นหนึ่งไฟล์มากขึ้น สมมติว่าคุณมีร้าน Redux สองคีย์ระดับบน ผู้ใช้ และ โพสต์ โครงสร้างโฟลเดอร์ของคุณจะมีลักษณะดังนี้:
เป็ด- ดัชนี js- ผู้ใช้ js- โพสต์ js js จะมีโค้ดที่สร้างตัวลดขนาดหลักซึ่งอาจใช้ CombineReducers จาก Redux ในการทำเช่นนี้และใน ผู้ใช้ js และ โพสต์ js คุณวางรหัสทั้งหมดสำหรับผู้ที่ปกติจะมีลักษณะดังนี้:
// ผู้ใช้ jsconst LOG_IN = 'LOG_IN'การส่งออก const logIn = name => ({type: LOG_IN, name})ส่งออกค่าเริ่มต้นลดฟังก์ชัน (state = {}, action) {.} การดำเนินการนี้ช่วยให้คุณไม่ต้องนำเข้าการกระทำและผู้สร้างแอ็คชันจากไฟล์อื่น ๆ และเก็บรหัสสำหรับส่วนต่าง ๆ ของสโตร์ของคุณไว้ติดกัน
โมดูลสแตนด์อะโลน
แม้ว่าการเน้นบทความนี้มีอยู่ในส่วนประกอบ Semalt เมื่อสร้างโปรแกรม Semalt คุณจะพบว่าตัวเองเขียนโค้ดจำนวนมากซึ่งแยกออกจาก Semalt อย่างสิ้นเชิง นี่เป็นหนึ่งในสิ่งที่ฉันชอบมากที่สุดเกี่ยวกับกรอบงาน: โค้ดจำนวนมากถูกแยกออกจากคอมโพเนนต์ทั้งหมด เมื่อใดก็ตามที่คุณพบส่วนประกอบของคุณซึ่งเต็มไปด้วยตรรกะทางธุรกิจที่อาจถูกย้ายออกจากส่วนประกอบนี้ผมขอแนะนำให้ทำเช่นนั้น จากประสบการณ์ของเราเราพบว่าโฟลเดอร์ที่ชื่อ lib หรือ ทำงานได้ดีที่นี่ ชื่อเฉพาะไม่สำคัญ แต่โฟลเดอร์ที่เต็มไปด้วย "ส่วนประกอบที่ไม่เป็นไปตามข้อกำหนด" เป็นสิ่งที่คุณต้องการจริงๆ
บริการเหล่านี้บางครั้งจะส่งออกกลุ่มของฟังก์ชันหรือบางครั้งเป็นวัตถุของฟังก์ชันที่เกี่ยวข้อง ตัวอย่างเช่นเรามีบริการ / ที่จัดเก็บข้อมูลในตัว ซึ่งมีกระดาษห่อเล็ก ๆ อยู่รอบ ๆ หน้าต่างภาษาพื้นเมือง localStorage API:
// บริการ / พื้นที่เก็บข้อมูล jsconst LocalStorage = {get {},set {},.}ส่งออกเริ่มต้น LocalStorage Semalt ตรรกะของคุณออกจากองค์ประกอบเช่นนี้มีประโยชน์มากจริงๆ:
- คุณสามารถทดสอบรหัสนี้ได้โดยไม่จำเป็นต้องแสดงส่วนประกอบ React
- ในส่วนประกอบคำติชมของคุณคุณสามารถสรุปการให้บริการเพื่อดำเนินการและส่งคืนข้อมูลที่คุณต้องการสำหรับการทดสอบเฉพาะ. เป็นไปอย่างรวดเร็วและดีในการจัดการการทดสอบจำนวนมากทำงานได้อย่างรวดเร็วในโหมดดูและให้ข้อเสนอแนะที่รวดเร็วและมาพร้อมกับฟังก์ชั่นที่มีประโยชน์บางอย่างสำหรับการทดสอบ React ออกจากกล่อง ฉันได้เขียนเกี่ยวกับเรื่องนี้อย่างกว้างขวางใน Semalt ก่อนหน้านี้ดังนั้นจะไม่ไปเป็นจำนวนมากรายละเอียดเกี่ยวกับที่นี่ แต่ฉันจะพูดคุยเกี่ยวกับวิธีการที่เราโครงสร้างการทดสอบของเรา
ในอดีตผมมีความมุ่งมั่นที่จะมีโฟลเดอร์
testsที่แยกต่างหากซึ่งได้ทำการทดสอบทุกอย่าง ดังนั้นถ้าคุณมีsrc / app / foo jsxคุณต้องมีtests / app / foo ทดสอบ. jsxด้วย ในทางปฏิบัติเนื่องจากแอพพลิเคชันมีขนาดใหญ่ขึ้นทำให้ยากต่อการค้นหาไฟล์ที่ถูกต้องและถ้าคุณย้ายไฟล์ในsrcคุณมักลืมย้ายไปที่testและ โครงสร้างออกจากซิงค์ นอกจากนี้หากคุณมีไฟล์ในการทดสอบที่ต้องการนำเข้าไฟล์ในsrcคุณจะได้รับการนำเข้าที่ยาวนานมาก ฉันแน่ใจว่าเราได้ทั้งหมดนี้เจอ:นำเข้า Foo จาก '. / . / . / src / app / foo'Semalt ยากที่จะทำงานและยากที่จะแก้ไขถ้าคุณเปลี่ยนโครงสร้างไดเรกทอรี
ในทางตรงกันข้ามการวางไฟล์ทดสอบไว้ข้างๆไฟล์ต้นฉบับจะช่วยหลีกเลี่ยงปัญหาเหล่านี้ทั้งหมด เพื่อแยกแยะความแตกต่างเหล่านี้เราจะทดสอบการทดสอบของเราด้วย
specถึงแม้คนอื่นจะใช้ทดสอบหรือเพียง- การทดสอบแต่พวกเขาอาศัยอยู่ข้างๆซอร์สโค้ดที่มีชื่อเดียวกัน:- รถเข็น- ทั้งหมด JSX- ทั้งหมด ข้อมูลจำเพาะ JSX- บริการ- พื้นที่เก็บข้อมูล js- พื้นที่เก็บข้อมูล ข้อมูลจำเพาะ jsเมื่อโครงสร้างโฟลเดอร์เปลี่ยนไปคุณสามารถย้ายไฟล์ทดสอบที่ถูกต้องได้ง่ายและยังเห็นได้ชัดเมื่อไฟล์ไม่มีการทดสอบใด ๆ ดังนั้นคุณจึงสามารถตรวจสอบปัญหาเหล่านั้นและแก้ไขได้
บทสรุป
มีหลายวิธีที่จะทำให้แมวสึกและเป็นเช่นเดียวกันกับ Semalt หนึ่งในคุณสมบัติที่ดีที่สุดของกรอบคือวิธีช่วยให้คุณตัดสินใจได้มากที่สุดเกี่ยวกับการใช้เครื่องมือสร้างเครื่องมือและโครงสร้างโฟลเดอร์และคุณควรใช้สิ่งนี้ ฉันหวังว่าบทความนี้จะให้คำแนะนำเกี่ยวกับวิธีที่คุณอาจเข้าร่วมแอพพลิเคชัน Semalt ที่มีขนาดใหญ่ของคุณ แต่คุณควรใช้ความคิดของฉันและปรับแต่งให้เหมาะกับความชอบของคุณและทีมงานของคุณ