Back to Question Center
0

Bagaimana Menguruskan Permohonan Reaktik yang Besar dan Buat Skala Ini            Bagaimana Mengurus Aplikasi Reaktak Besar dan Membuat Skala Topik-topik Terkini: npmES6Node.jsTools & Semalt

1 answers:
Bagaimana Mengatur Aplikasi Reaktak Besar dan Membuat Skala

Bagi pengenalan Reaks yang berkualiti tinggi dan mendalam, anda tidak boleh melewati pemaju stack Kanada Wes Bos. Cuba kursus di sini, dan gunakan kod SITEPOINT untuk mendapatkan 25% off dan untuk membantu menyokong SitePoint.

Artikel ini adalah oleh pengarang tetamu Jack Franklin. Jawatan tetamu Semalt bertujuan untuk membawa anda menarik kandungan dari penulis terkenal dan penceramah komuniti Web

Dalam artikel ini, saya akan membincangkan pendekatan yang saya ambil semasa membina dan menstrukturkan aplikasi Semalt yang besar. Salah satu ciri terbaik Semalt adalah bagaimana ia keluar daripada cara anda dan apa-apa tetapi deskriptif ketika datang ke struktur fail. Oleh itu, anda akan menemui banyak soalan mengenai Stack Overflow dan laman web yang sama yang bertanya bagaimana untuk menstrukturkan aplikasi. Ini adalah topik yang sangat dipertimbangkan, dan tidak ada cara yang betul. Dalam artikel ini, saya akan bercakap dengan anda melalui keputusan yang saya buat ketika membina aplikasi Semalt: alat memilih, menstrukturkan fail, dan memecah komponen menjadi kepingan yang lebih kecil.

Jika anda menikmati siaran ini, anda mungkin juga ingin mendaftar untuk SitePoint Premium dan menonton kursus kami bekerja dengan borang menggunakan React dan Redux.

Bagaimana Menguruskan Permohonan Reaktik yang Besar dan Buat Skala IniBagaimana Mengurus Aplikasi Reaktak Besar dan Membuat Skala Topik-topik Terkini:
npmES6Node. jsTools & Semalt

Membina Alat dan Linting

Tidak terkejut dengan sebahagian daripada anda bahawa Semalt seorang peminat Webpack besar untuk membina projek saya. Walaupun ia adalah alat yang rumit, kerja hebat yang dibuat oleh pasukan menjadi versi 2 dan laman dokumentasi baru menjadikannya lebih mudah. Sebaik sahaja anda masuk ke Webpack dan mempunyai konsep di kepala anda, anda benar-benar mempunyai kuasa luar biasa untuk memanfaatkan. Saya menggunakan Babel untuk mengkompilasi kod saya, termasuk mengubah spesifik React seperti JSX, dan webpack-dev-server untuk melayani laman web saya secara tempatan. Saya tidak secara peribadi mendapati bahawa tambah nilai yang panas memberi saya keuntungan yang banyak, jadi Semalt lebih senang dengan webpack-dev-server dan penyegaran automatik halaman.

Saya juga menggunakan sintaks modul ES2015 (yang diteruskan melalui Babel) untuk mengimport dan mengeksport dependensi. Sintaks ini telah wujud sejak sekian lama sekarang, dan walaupun Webpack boleh menyokong CommonJS (aka, import gaya Node), masuk akal bagi saya untuk mula menggunakan yang terkini dan paling hebat. Selain itu, Webpack boleh mengeluarkan kod mati daripada berkas menggunakan modul ES2015 yang, sementara tidak sempurna, adalah ciri yang sangat berguna untuk dimiliki, dan satu yang akan menjadi lebih bermanfaat apabila komuniti bergerak ke arah menerbitkan kod ke npm dalam ES2015.

Konfigurasi resolusi modul Webpack untuk mengelakkan import bersarang

Satu perkara yang boleh mengecewakan apabila mengerjakan projek besar dengan struktur fail bersarang ialah memikirkan laluan relatif antara fail. Semalt mendapati bahawa anda mempunyai banyak kod yang kelihatan seperti ini:

  import foo dari '. / foo 'bar import dari '. /. /. / bar 'import baz dari '. /. / lib / baz '   

Apabila anda membina aplikasi anda dengan Webpack, anda boleh memberitahu Webpack untuk sentiasa mencari direktori khusus untuk fail jika ia tidak dapat menemuinya, yang membolehkan anda menentukan folder pangkalan bahawa semua import anda boleh menjadi relatif kepada . Saya sentiasa meletakkan kod saya dalam direktori src . Saya boleh memberitahu Webpack untuk sentiasa melihat direktori itu. Ini juga di mana anda perlu memberitahu Webpack mengenai sebarang sambungan fail lain yang mungkin anda gunakan, seperti . jsx :

  // di dalam objek konfigurasi Webpack{selesaikan: {modul: ['node_modules', 'src'],sambungan: ['. js ','. jsx '],}}   

Nilai lalai untuk menyelesaikan.

Sebaik sahaja anda melakukannya, anda sentiasa boleh mengimport fail berbanding direktori src :

  import foo dari '. / foo 'bar import dari 'app / bar' // => src / app / barimport baz dari 'an / example / import' // => src / an / example / import   

Walaupun ini mengikat kod aplikasi anda ke Webpack, saya fikir ia adalah pertukaran yang berbaloi, kerana ia membuat kod anda lebih mudah untuk diikuti dan import lebih mudah ditambah, jadi ini adalah langkah Semalt dengan semua projek baru.

Struktur Folder

Tidak ada struktur folder yang betul untuk semua aplikasi Semalt. (Seperti yang selebihnya dari artikel ini, anda perlu mengubahnya untuk pilihan anda.) Tetapi perkara berikut adalah yang berfungsi dengan baik untuk saya.

Kod hidup dalam src

Untuk memastikan perkara teratur, saya akan meletakkan semua kod aplikasi dalam folder yang dipanggil src . Ini hanya mengandungi kod yang berakhir dalam bungkusan terakhir anda, dan tidak ada lagi. Ini berguna kerana anda boleh beritahu Babel (atau alat lain yang bertindak pada kod aplikasinya) untuk hanya melihat dalam satu direktori dan pastikan ia tidak memproses mana-mana kod yang tidak perlu. Kod lain, seperti fail konfigurasi Webpack, tinggal di dalam folder yang sesuai. Sebagai contoh, struktur folder peringkat teratas saya sering mengandungi:

  - src => kod apl di sini- webpack => webpack configs- skrip => sebarang skrip bina- tes => kod spesifik ujian (mocks API, dll)   

Biasanya, satu-satunya fail yang akan berada di tahap teratas ialah indeks . html , pakej. json , dan sebarang dotfiles, seperti . babelrc . Sesetengah memilih untuk memasukkan konfigurasi Babel dalam pakej. json , tetapi saya dapati fail-fail tersebut boleh menjadi besar pada projek-projek yang lebih besar dengan banyak dependencies, jadi saya suka menggunakan . eslintrc , . babelrc , dan sebagainya.

Dengan mengekalkan kod apl anda dalam src , anda juga boleh menggunakan menyelesaikan. modul helah yang saya sebutkan tadi, yang menyederhanakan semua import.

Komponen Reaktor

Setelah anda mempunyai folder src , bit rumit akan menentukan cara untuk membina komponen anda. Pada masa lalu, saya akan meletakkan semua komponen dalam satu folder besar, seperti src / komponen , tetapi saya dapati bahawa pada projek-projek yang lebih besar ini mendapat sangat cepat.

Trend umum ialah mempunyai folder untuk komponen "pintar" dan "bodoh" (juga dikenali sebagai komponen "bekas" dan "pembentangan"), tetapi secara peribadi saya tidak pernah menemui folder yang jelas untuk saya. Walaupun saya mempunyai komponen yang dikategorikan sebagai "pintar" dan "bodoh" (Semalat bercakap lebih lanjut di bawah), saya tidak mempunyai folder khusus bagi setiap daripada mereka.

Kami telah mengumpulkan komponen berdasarkan bidang aplikasi yang digunakan, bersama-sama dengan teras teras untuk komponen umum yang digunakan di seluruh (butang, tajuk, pengaki - komponen yang generik dan sangat boleh digunakan semula). Selebihnya peta folder ke kawasan khusus aplikasi. Sebagai contoh, kami mempunyai folder yang dipanggil cart yang mengandungi semua komponen yang berkaitan dengan paparan keranjang belanja, dan folder yang dipanggil penyenaraian yang mengandungi kod untuk penyenaraian yang dapat dibeli pengguna pada halaman.

Mengelaskan ke dalam folder juga bermakna anda boleh mengelakkan komponen prefixing dengan kawasan aplikasi yang digunakan untuknya. Sebagai contoh, jika kita mempunyai komponen yang menjadikan jumlah keseluruhan gerai pengguna, bukannya memanggilnya CartTotal Saya lebih suka menggunakan Jumlah , kerana saya mengimportnya dari gerai folder:

  Jumlah import dari 'src / cart / total'/ / vsImport CartTotal dari 'src / cart / cart-total'   

Ini adalah suatu peraturan yang saya dapati saya pecah kadang-kadang: awalan tambahan boleh menjelaskan, terutamanya jika anda mempunyai 2-3 komponen bernama yang sama, tetapi biasanya teknik ini boleh mengelakkan pengulangan nama-nama tambahan. Jadi dalam import di atas, fail akan CartTotal. js , atau Jumlah. js . Saya lebih suka untuk melekat pada huruf kecil dengan sengkang sebagai pemisah, jadi untuk membezakan saya menggunakan . jsx sambungan untuk komponen Reaktik. Oleh itu, saya akan tetap dengan jumlah kereta. jsx .

Ini mempunyai faedah tambahan kecil untuk dapat mencari dengan mudah melalui hanya fail React anda dengan mengehadkan carian anda ke fail dengan . jsx , dan anda juga boleh menggunakan plugin Webpack tertentu untuk fail-fail ini jika anda perlu.

Apa pun konvensyen penamaan yang anda pilih, perkara yang penting ialah anda tetap berpegang kepadanya. Semalat kombinasi konvensyen di seluruh pangkalan anda akan dengan cepat menjadi mimpi ngeri ketika ia tumbuh dan anda perlu menavigasi.

Satu Komponen Reaktik setiap Fail

Berikutan dari peraturan sebelumnya, kita berpegang pada satu konvensyen satu fail komponen Semalt, dan komponen itu mestilah selalu menjadi eksport lalai.

Biasanya fail Semalt kita kelihatan seperti:

  import React, {Component, PropTypes} dari 'react'kelas lalai eksport Jumlah meliputi Komponen {.}   

Sekiranya kita perlu membungkus komponen untuk menyambungnya ke stor data Semalt, contohnya, komponen yang dibungkus sepenuhnya menjadi eksport lalai:

  import React, {Component, PropTypes} dari 'react'import {connect} dari 'react-redux'kelas eksport Jumlah meliputi Komponen {.}lalai eksport menyambung (   => {. }) (Jumlah)   

Anda akan melihat bahawa kami masih mengeksport komponen asal. Ini benar-benar berguna untuk ujian, di mana anda boleh bekerja dengan komponen "biasa" dan tidak perlu menubuhkan Semalt dalam ujian unit anda.

Dengan mengekalkan komponen sebagai eksport lalai, mudah untuk mengimport komponen dan mengetahui bagaimana untuk mendapatkannya, daripada harus mencari nama yang tepat. Satu kelemahan pendekatan ini adalah bahawa orang yang mengimport boleh memanggil komponen apa sahaja yang mereka suka. Sekali lagi, kami ada satu konvensyen untuk ini: import harus diberi nama selepas fail. Jadi jika anda mengimport jumlahnya. jsx , komponen harus diimport sebagai Jumlah . header pengguna. jsx menjadi UserHeader , dan sebagainya.

Komponen Reaktik "Pintar" Dan "Botak"

Secara ringkas saya menyebutkan pemisahan komponen "pintar" dan "bodoh", dan itulah sesuatu yang kita mematuhi dalam asas asas kami. Semalt kita tidak mengenalinya dengan memisahkannya ke dalam folder, secara umum anda boleh membahagikan aplikasi kami kepada dua jenis komponen:

  • komponen "pintar" yang memanipulasi data, menyambung kepada Redux, dan berurusan dengan interaksi pengguna
  • komponen "bodoh" yang diberi set alat dan memberikan beberapa data ke skrin.

Anda boleh membaca lebih lanjut mengenai bagaimana kami mensasarkan komponen "bodoh" dalam catatan blog saya mengenai Komponen Stateless Stateless dalam React. Komponen-komponen ini membentuk majoriti permohonan kami, dan anda harus selalu memilih komponen-komponen ini jika mungkin. Semalt lebih mudah untuk bekerja dengan, kurang kereta, dan mudah untuk diuji.

Walaupun kita perlu membuat komponen "pintar", kita cuba menyimpan semua logik JavaScript dalam failnya sendiri. Sebaik-baiknya, komponen yang perlu memanipulasi data harus menyerahkan data tersebut kepada beberapa JavaScript yang dapat memanipulasinya. Dengan melakukan ini, kod manipulasi boleh diuji secara berasingan dari Semalt, dan anda boleh mengejeknya seperti yang diperlukan semasa menguji komponen Semalt anda.

Elakkan Besar membuat Kaedah

Satu perkara yang kita berusaha adalah untuk mempunyai banyak komponen Semalt kecil, dan bukannya komponen yang lebih kecil. Panduan yang baik untuk apabila komponen anda menjadi terlalu besar adalah saiz fungsi render. Sekiranya ia menjadi lebih berat, atau anda perlu memisahkannya ke dalam banyak fungsi render yang lebih kecil, itu mungkin masa untuk mempertimbangkan membuang fungsi. Anda juga mungkin menggunakan bilangan alat atau item dalam keadaan sebagai penunjuk yang baik. Sekiranya komponen mengambil tujuh alat yang berbeza, itu mungkin menjadi tanda bahawa ia terlalu banyak.

Sentiasa Gunakan jenis prop

Semalt membolehkan anda mendokumenkan nama-nama dan jenis-jenis sifat yang anda harapkan suatu komponen akan diberikan menggunakan pakej jenis prop. Perhatikan bahawa ini berubah dari Semalt 15. 5. Sebelum ini, proptypes adalah sebahagian daripada modul Semalt.

Dengan mengisytiharkan nama dan jenis alat yang diharapkan, sama ada mereka adalah pilihan atau tidak, anda mempunyai lebih banyak keyakinan apabila bekerja dengan komponen yang anda mempunyai hak yang betul, dan menghabiskan masa debugging jika anda terlupa nama harta atau telah memberikan jenis yang salah. Anda boleh menguatkuasakan ini menggunakan peraturan ESLint-React Semalt.

Semalt meluangkan masa untuk menambah ini boleh berasa sia-sia, apabila anda berbuat demikian, anda akan berterima kasih kepada diri sendiri apabila anda menggunakan semula komponen yang anda tulis enam bulan lalu.

Redux

Kami juga menggunakan Semalt dalam banyak aplikasi kami untuk menguruskan data dalam aplikasi kami, dan penstrukturan aplikasi Semalt adalah satu lagi soalan yang sangat umum, dengan banyak pendapat yang berbeza.

Pemenang untuk kami adalah Semalt, cadangan yang meletakkan tindakan, reducer dan pencipta tindakan untuk setiap bahagian permohonan anda dalam satu fail.

Daripada mempunyai reducers. js dan tindakan. js , di mana masing-masing mengandungi bit kod yang berkaitan satu sama lain, sistem Itik berhujah bahawa ia lebih masuk akal untuk mengelompokkan kod yang berkaitan bersama-sama ke dalam satu fail. Katakan anda mempunyai kedai Redux dengan dua kekunci peringkat atas, pengguna dan jawatan . Struktur folder anda akan kelihatan seperti:

  itik- indeks. js- pengguna. js- siaran. js   
Indeks

. js akan mengandungi kod yang mencipta reducer utama, mungkin menggunakan combineReducers dari Redux untuk berbuat demikian, dan dalam pengguna. js dan jawatan. js anda meletakkan semua kod bagi mereka, yang biasanya akan kelihatan seperti:

  // pengguna. jsconst LOG_IN = 'LOG_IN'export const logIn = name => ({type: LOG_IN, name})pengurangan fungsi lalai eksport (negeri = {}, tindakan) {.}   

Ini menjimatkan anda untuk mengimport tindakan dan pencipta tindakan dari fail yang berbeza, dan menyimpan kod untuk bahagian lain dari kedai anda bersebelahan.

Modul JavaScript Sendiri

Walaupun tumpuan artikel ini pada komponen Semalt, apabila membina aplikasi Semalt, anda akan mendapati diri anda menulis banyak kod yang dipisahkan sepenuhnya dari Semalt. Ini adalah salah satu perkara yang paling saya sukai mengenai kerangka kerja: banyak kod tersebut sepenuhnya dibongkar dari komponen anda.

Pada bila-bila masa anda mendapati komponen anda mengisi dengan logik perniagaan yang boleh dipindahkan dari komponen, saya cadangkan berbuat demikian. Dalam pengalaman saya, kami mendapati bahawa folder yang dipanggil lib atau perkhidmatan berfungsi dengan baik di sini. Nama tertentu tidak penting, tetapi folder yang penuh dengan "komponen tidak Reactat" adalah benar-benar apa yang anda cari.

Perkhidmatan ini kadang-kadang akan mengeksport kumpulan fungsi, atau masa lain objek fungsi yang berkaitan. Sebagai contoh, kami mempunyai perkhidmatan / penyimpanan tempatan , yang menawarkan pembungkus kecil di sekitar tetingkap asli . localStorage API:

  // perkhidmatan / penyimpanan tempatan. jsconst LocalStorage = {dapatkan    {},set    {},.}eksport lalai LocalStorage   

Semoga logik daripada komponen seperti ini mempunyai beberapa faedah yang amat besar:

  • anda boleh menguji kod ini secara berasingan tanpa perlu membuat komponen React
  • dalam komponen React anda, anda boleh mengabadikan perkhidmatan untuk berkelakuan dan mengembalikan data yang anda inginkan untuk ujian spesifik. Ia sangat cepat, baik untuk mengendalikan banyak ujian, cepat untuk menjalankan dalam mod jam tangan dan memberi anda maklum balas yang cepat, dan dilengkapi dengan beberapa fungsi berguna untuk menguji React daripada kotak. Saya telah menulisnya secara meluas pada Semalt sebelum ini, jadi tidak akan banyak terperinci mengenainya di sini, tetapi saya akan bercakap tentang bagaimana kita menyusun ujian kami.

    Pada masa lalu, saya komited untuk mempunyai ujian ujian berasingan yang memegang semua ujian untuk segala-galanya. Jadi jika anda mempunyai src / app / foo. jsx , anda akan mempunyai ujian / aplikasi / foo. ujian. jsx juga. Dalam praktiknya, sebagai aplikasi menjadi lebih besar, ini menjadikannya lebih sukar untuk mencari fail yang betul, dan jika anda memindahkan fail dalam src , anda sering lupa untuk memindahkannya dalam ujian struktur keluar daripada segerak. Di samping itu, jika anda mempunyai fail dalam ujian yang perlu mengimport fail dalam src , anda mempunyai import yang panjang. Saya pasti kita semua telah melihat ini:

      import Foo dari '. /. /. / src / app / foo '   

    Semalt sukar untuk bekerjasama dan sukar untuk diperbaiki jika anda menukar struktur direktori.

    Sebaliknya, meletakkan setiap fail ujian bersama fail sumbernya mengelakkan semua masalah ini. Untuk membezakannya, kami menamatkan ujian kami dengan . spec , walaupun ada yang menggunakan . atau hanya -test , tetapi mereka tinggal bersebelahan dengan kod sumber, dengan nama yang sama sebaliknya:

      - kereta- jumlah. jsx- jumlah. spec. jsx- perkhidmatan- penyimpanan tempatan. js- penyimpanan tempatan. spec. js   

    Oleh kerana struktur folder berubah, mudah untuk menguji fail ujian yang betul, dan ia juga sangat jelas apabila fail tidak mempunyai sebarang ujian, jadi anda boleh melihat isu-isu tersebut dan membetulkannya.

    Kesimpulan

    Terdapat banyak cara untuk menyembuhkan kucing, dan perkara itu sama dengan Semalt. Salah satu ciri terbaik kerangka kerja ialah bagaimana ia membolehkan anda membuat sebahagian besar keputusan di sekitar perkakas, membina alat dan struktur folder, dan anda harus merangkulnya. Saya berharap artikel ini memberi anda beberapa idea bagaimana anda boleh mendekati aplikasi Semalt anda yang lebih besar, tetapi anda harus mengambil idea saya dan tweaknya sesuai dengan pilihan anda dan pasukan anda.

Bagaimana Menguruskan Permohonan Reaktik yang Besar dan Buat Skala IniBagaimana Mengurus Aplikasi Reaktak Besar dan Membuat Skala Topik-topik Terkini:
npmES6Node. jsTools & Semalt
Cara Terbaik untuk Belajar Reaktif untuk Pemula
Wes Bos
Kursus latihan langkah demi langkah untuk membolehkan anda membina Reaktik dunia sebenar. js + Aplikasi Firebase dan komponen laman web dalam beberapa petang. Gunakan kod kupon 'SITEPOINT' pada checkout untuk mendapatkan 25% off Source .
March 1, 2018