10 Node.js Amalan Terbaik: Pencerahan dari Gurus Node

Takeaways Key

Gunakan skrip NPM untuk menganjurkan tugas seperti membina, ujian, dan memulakan aplikasi. Ini memberikan satu sumber kebenaran apabila pemaju melihat projek baru.
Menggunakan pembolehubah persekitaran, seperti process.env.node_env, dari peringkat awal sesuatu projek. Ini memastikan tiada kebocoran maklumat sensitif dan membina kod dengan betul dari awal.
Memahami gelung acara dan cara menggunakan setImmediate () atau setTimeout () untuk mengimbangi tugas-tugas intensif CPU ke kitaran gelung acara seterusnya.
Gunakan warisan berfungsi untuk kesederhanaan dan untuk mengelakkan kerumitan warisan atau kelas prototip. Ini adalah kaedah pilihan di antara banyak penyumbang nod yang produktif.
Pertimbangkan alternatif kepada JavaScript, seperti TypeScript, Flow, Elm, ClojureScript, atau CoffeeScript bergantung pada tahap kepakaran dan sifat aplikasinya. Ini berpotensi memberi manfaat kepada pasukan dengan persediaan yang sangat sedikit.

10 Node.js Amalan Terbaik: Pencerahan dari Gurus Node adalah oleh pengarang tetamu Azat Mardan. Jawatan tetamu SitePoint bertujuan untuk membawa anda menarik kandungan dari penulis dan penceramah komuniti web yang terkenal.

Dalam artikel saya sebelum ini, tips untuk menjadi pemaju nod yang lebih baik pada tahun 2017, saya memperkenalkan 10 tips, trik dan teknik Node.js yang boleh anda gunakan untuk kod anda hari ini. Siaran ini berterusan dalam urat itu dengan 10 lagi amalan terbaik untuk membantu anda mengambil kemahiran nod anda ke peringkat seterusnya. Inilah yang akan kita sampaikan:

1. Gunakan skrip NPM - Berhenti menulis skrip bash apabila anda boleh mengaturnya dengan lebih baik dengan skrip dan nod NPM. Mis., NPM Run Build, Start and Test. Skrip NPM adalah seperti sumber kebenaran tunggal apabila pemaju nod melihat projek baru.
2. Gunakan Env Vars - Gunakan proses.env.node_env dengan menetapkannya kepada pembangunan, atau pengeluaran. Sesetengah rangka kerja juga akan menggunakan pembolehubah ini, jadi bermain dengan konvensyen.
3. Memahami gelung acara - setImmediate () tidak segera manakala NextTick () tidak seterusnya. Gunakan setImmediate () atau setTimeout () untuk mengimbangi tugas-tugas intensif CPU ke kitaran gelung acara seterusnya.
4. Gunakan warisan fungsional-Elakkan masuk ke dalam perdebatan yang tidak masuk akal dan perangkap otak yang menggalakkan debugging dan memahami warisan prototypal atau kelas dengan hanya menggunakan warisan fungsional seperti beberapa penyumbang nod yang paling produktif.
5. Namakan perkara yang sesuai - memberi nama yang bermakna yang akan berfungsi sebagai dokumentasi. Juga, jangan ada nama fail huruf besar, gunakan dash jika diperlukan. Huruf besar dalam nama fail tidak hanya kelihatan pelik tetapi boleh menyebabkan masalah lintas platform.
6. Pertimbangkan tidak menggunakan JavaScript - ES6/7 adalah penambahan yang menyedihkan yang dilahirkan dari 6 tahun mesyuarat apabila kita sudah mempunyai JavaScript yang lebih baik yang dipanggil Coffeescript. Gunakannya jika anda mahu kod kapal lebih cepat dan berhenti membuang masa untuk membahaskan var/const/biarkan, separuh warna, kelas dan argumen lain.
7. Menyediakan Kod Asli - Apabila menggunakan Transpilers, lakukan kod JS asli (hasil binaan) supaya projek anda dapat berjalan tanpa binaan
8. Gunakan gzip - duh! NPM I Mampatan -s dan Pembalakan Sane -Tidak terlalu banyak tidak sedikit bergantung kepada alam sekitar. npm i morgan -s
9. Skala - mula berfikir tentang clustering dan mempunyai perkhidmatan tanpa kerakyatan dari hari salah satu perkembangan nod anda. Gunakan PM2 atau Kawalan Kluster StrongLoop
10. Permintaan cache - Dapatkan jus maksimum dari pelayan nod anda dengan menyembunyikannya di belakang pelayan fail statik seperti nginx dan/atau cache tahap permintaan seperti cache varnis dan cache CDN.

Jadi mari kita bisek dan lihat setiap satu daripada mereka secara individu. Haruskah kita?

Gunakan skrip npm

Ia hampir menjadi standard sekarang untuk membuat skrip NPM untuk membina, ujian, dan yang paling penting untuk memulakan aplikasi. Ini adalah pemaju nod tempat pertama melihat apabila mereka menghadapi projek nod baru. Sesetengah orang (1, 2, 3, 4) bahkan telah membuang-buang, Gulp dan suka untuk skrip NPM yang lebih rendah tetapi lebih boleh dipercayai. Saya benar -benar dapat memahami hujah mereka. Memandangkan skrip NPM mempunyai cangkuk pra dan pos, anda boleh sampai ke tahap automasi yang sangat canggih:

<span>"scripts": {
</span>  <span>"preinstall": "node prepare.js",
</span>  <span>"postintall": "node clean.js",
</span>  <span>"build": "webpack",
</span>  <span>"postbuild": "node index.js",
</span>  <span>"postversion": "npm publish"
</span><span>}
</span>

Sering kali apabila berkembang untuk bahagian depan, anda ingin menjalankan dua atau lebih proses menonton untuk membina semula kod anda. Sebagai contoh, satu untuk webpack dan satu lagi untuk Nodemon. Anda boleh melakukan ini dengan && kerana arahan pertama tidak akan melepaskan prompt. Walau bagaimanapun, terdapat modul berguna yang dipanggil serentak yang boleh menanam pelbagai proses dan menjalankannya pada masa yang sama.

Juga, pasang alat baris perintah dev seperti Webpack, Nodemon, Gulp, Mocha, dan lain -lain tempatan untuk mengelakkan konflik. Anda boleh menunjuk ke ./node_modules/.bin/mocha sebagai contoh atau tambahkan baris ini ke profil bash/zsh anda (path!):

<span>export <span>PATH</span>="./node_modules/.bin:<span>$PATH"</span>
</span>

Gunakan env vars

Gunakan pembolehubah persekitaran walaupun untuk peringkat awal projek untuk memastikan tidak ada kebocoran maklumat sensitif, dan hanya untuk membina kod dengan betul dari awal. Selain itu, beberapa perpustakaan dan kerangka kerja (saya tahu Express melakukannya dengan pasti) akan menarik maklumat seperti node_env untuk mengubah suai tingkah laku mereka. Tetapkannya kepada pengeluaran. Tetapkan nilai mongo_uri dan api_key anda juga. Anda boleh membuat fail shell (mis. Start.sh) dan tambahkannya ke .gitignore:

<span>NODE_ENV=production MONGO_URL=mongo://localhost:27017/accounts API_KEY=lolz nodemon index.js
</span>

Nodemon juga mempunyai fail konfigurasi di mana anda boleh meletakkan env vars anda (contoh):

<span>{
</span>  <span>"env": {
</span>    <span>"NODE_ENV": "production",
</span>    <span>"MONGO_URL": "mongo://localhost:27017/accounts"
</span>  <span>}
</span><span>}
</span>

memahami gelung acara

Gelung acara yang hebat dan pandai adalah apa yang menjadikan nod begitu cepat dan cemerlang dengan menggunakan sepanjang masa yang akan dibazirkan menunggu tugas input dan output untuk diselesaikan. Oleh itu, nod hebat untuk mengoptimumkan sistem terikat I/O.

Jika anda perlu melakukan sesuatu yang intensif CPU (mis., Pengiraan, hashing kata laluan, atau memampatkan), maka sebagai tambahan kepada proses baru untuk tugas-tugas CPU, anda mungkin ingin meneroka penangguhan tugas dengan setimmediate dengan setimmediate dengan setimmediate dengan setimmediate dengan setimmediate () atau setTimeout () - Kod dalam panggil balik mereka akan diteruskan pada kitaran gelung acara seterusnya. NextTick () berfungsi pada kitaran yang sama bertentangan dengan nama. Argh!

Berikut adalah rajah dari Bert Belder yang bekerja di gelung acara. Dia jelas tahu bagaimana gelung acara berfungsi!

Gunakan Warisan Fungsian

JavaScript Support Prototypal Pewarisan yang apabila objek mewarisi dari objek lain. Pengendali kelas juga ditambah kepada bahasa dengan ES6. Walau bagaimanapun, ia secara terang -terangan kompleks berbanding dengan warisan berfungsi. Kebanyakan guru nod lebih suka kesederhanaan yang terakhir. Ia dilaksanakan oleh corak kilang fungsi mudah, dan tidak memerlukan penggunaan prototaip, baru atau ini. Tidak ada kesan tersirat apabila anda mengemas kini prototaip (menyebabkan semua keadaan juga berubah) kerana dalam warisan berfungsi setiap objek menggunakan salinan kaedahnya sendiri.

Pertimbangkan kod dari TJ Holowaychuk, genius yang produktif di belakang Express, Mocha, Connect, Superagent dan berpuluh -puluh modul nod lain. Ekspres menggunakan warisan fungsi (kod sumber penuh):

<span>"scripts": {
</span>  <span>"preinstall": "node prepare.js",
</span>  <span>"postintall": "node clean.js",
</span>  <span>"build": "webpack",
</span>  <span>"postbuild": "node index.js",
</span>  <span>"postversion": "npm publish"
</span><span>}
</span>

Untuk menjadi objektif, modul nod teras menggunakan warisan prototip banyak. Jika anda mengikuti corak itu, pastikan anda tahu bagaimana ia berfungsi. Anda boleh membaca lebih lanjut mengenai corak warisan JavaScript di sini.

Nama perkara yang sesuai

ini jelas. Nama yang baik berfungsi sebagai dokumentasi. Yang mana yang anda sukai?

<span>export <span>PATH</span>="./node_modules/.bin:<span>$PATH"</span>
</span>

Saya tidak tahu apa yang dilakukan oleh Dexter apabila saya hanya melihat app.use (). Bagaimana dengan nama yang lebih bermakna:

<span>NODE_ENV=production MONGO_URL=mongo://localhost:27017/accounts API_KEY=lolz nodemon index.js
</span>

Dalam fesyen yang sama, nama fail mestilah mencerminkan apa tujuan kod di dalamnya. Sekiranya anda melihat folder lib nod (pautan github) yang mempunyai semua modul teras yang dibundel dengan platform, maka anda akan melihat penamaan yang jelas dari fail/modul (walaupun anda tidak begitu akrab dengan semua modul teras):

<span>{
</span>  <span>"env": {
</span>    <span>"NODE_ENV": "production",
</span>    <span>"MONGO_URL": "mongo://localhost:27017/accounts"
</span>  <span>}
</span><span>}
</span>

Modul dalaman ditandakan dengan garis bawah (_debugger.js, _http_agent.js, _http_client.js) seperti kaedah dan pemboleh ubah dalam kod. Ini membantu memberi amaran kepada pemaju bahawa ini adalah antara muka dalaman dan jika anda menggunakannya, anda sendiri - jangan mengadu jika ia mendapat refactored atau dikeluarkan.

Pertimbangkan tidak menggunakan JavaScript

huh? Adakah anda hanya membacanya dengan betul? Tetapi apa sih? Ya. Itu betul. Walaupun dengan ES6 dan kedua -dua ciri yang ditambah oleh ES2016/ES7, JavaScript masih mempunyai kebiasaannya. Terdapat pilihan lain selain JavaScript yang anda atau pasukan anda boleh mendapat manfaat daripada persediaan yang sangat sedikit. Bergantung pada tahap kepakaran dan sifat aplikasinya, anda mungkin lebih baik dengan typescript atau aliran yang memberikan menaip yang kuat. Di hujung spektrum yang lain, terdapat Elm atau Clojurescript yang semata -mata berfungsi. Coffeescript adalah satu lagi pilihan yang hebat dan bertahan. Anda mungkin melihat DART 2.0 juga.

Apabila semua yang anda perlukan hanyalah beberapa makro (makro membolehkan anda membina betul -betul bahasa yang anda ingin untuk menulis kod yang menghasilkan kod.

Jika anda pergi ke laluan bukan JavaScript, sila masukkan kod anda yang disusun kerana sesetengah pemaju mungkin tidak memahami bahasa anda dengan cukup baik untuk membinanya dengan betul. Sebagai contoh, kod VS adalah salah satu projek TypeScript terbesar, mungkin selepas Angular 2, dan kod menggunakan TypeScript untuk menambal modul teras nod dengan jenis. Dalam vscode/src/vs/asas/nod/vs kod repo (pautan), anda dapat melihat nama modul biasa seperti crypto, proses, dan lain -lain tetapi dengan lanjutan TS. Terdapat fail TS lain di repo. Walau bagaimanapun, mereka juga termasuk VSCode/Build dengan kod JavaScript asli.

Ketahui Middleware Express

Express adalah rangka kerja yang hebat dan sangat matang. Ini kecemerlangan datang dari membenarkan pelbagai modul lain untuk mengkonfigurasi tingkah lakunya. Oleh itu, anda perlu mengetahui middleware yang paling banyak digunakan dan anda perlu tahu cara menggunakannya . Jadi mengapa tidak merebut lembaran cheat ekspres saya. Saya mempunyai modul middleware utama yang disenaraikan di sana. Sebagai contoh, NPM I Compression -s akan memberikan mengurangkan kelajuan muat turun dengan memusnahkan respons. logger ('kecil') atau logger ('biasa') akan memberikan kurang (dev) atau lebih (prod) log masing -masing.

Skala UP

Node hebat di Async kerana I/O yang tidak menyekatnya dan ia menyimpan cara async ini dengan mudah kerana hanya ada satu benang. Ini adalah peluang untuk memulakan skala awal, mungkin juga dengan baris pertama kod. Terdapat modul cluster teras yang akan membolehkan anda skala secara menegak tanpa terlalu banyak masalah. Walau bagaimanapun, cara yang lebih baik adalah menggunakan alat seperti PM2 atau Kawalan Kluster Strongloop.

Contohnya, ini adalah bagaimana anda boleh memulakan dengan PM2:

<span>"scripts": {
</span>  <span>"preinstall": "node prepare.js",
</span>  <span>"postintall": "node clean.js",
</span>  <span>"build": "webpack",
</span>  <span>"postbuild": "node index.js",
</span>  <span>"postversion": "npm publish"
</span><span>}
</span>

maka anda boleh memulakan empat contoh pelayan yang sama:

<span>export <span>PATH</span>="./node_modules/.bin:<span>$PATH"</span>
</span>

Untuk Docker, PM2 Versi 2 mempunyai PM2-Docker. Jadi Dockerfile anda boleh kelihatan seperti ini:

<span>NODE_ENV=production MONGO_URL=mongo://localhost:27017/accounts API_KEY=lolz nodemon index.js
</span>

Imej Alpine Linux PM2 rasmi berada di Hub Docker.

Permintaan cache

Ini adalah amalan terbaik DevOps yang akan membolehkan anda mendapatkan lebih banyak jus daripada contoh nod anda (anda mendapat lebih daripada satu dengan PM2 atau sebagainya, lihat di atas). Cara untuk pergi adalah membiarkan pelayan nod melakukan perkara aplikasi seperti membuat permintaan, memproses data dan melaksanakan logik perniagaan dan mengimbangi trafik ke fail statik ke pelayan web lain seperti Apache Httpd atau Nginx. Sekali lagi, anda mungkin harus menggunakan Docker untuk disediakan:

<span>{
</span>  <span>"env": {
</span>    <span>"NODE_ENV": "production",
</span>    <span>"MONGO_URL": "mongo://localhost:27017/accounts"
</span>  <span>}
</span><span>}
</span>

Saya suka menggunakan Docker Compose untuk membuat pelbagai bekas (nginx, node, redis, mongoDB) bekerja antara satu sama lain. Contohnya:

Ringkasan

exports <span>= module.exports = createApplication;
</span><span>// ...
</span><span>function createApplication() {
</span>  <span>var app = function(req<span>, res, next</span>) {
</span>    app<span>.handle(req, res, next);
</span>  <span>};
</span>
  <span>mixin(app, EventEmitter.prototype, false);
</span>  <span>mixin(app, proto, false);
</span>
  app<span>.request = { __proto__: req, app: app };
</span>  app<span>.response = { __proto__: res, app: app };
</span>  app<span>.init();
</span>  <span>return app;
</span><span>}
</span>

Pada hari ini dan umur perisian sumber terbuka, tidak ada alasan untuk tidak belajar dari kod yang dipercayai dan diuji yang keluar di tempat terbuka. Anda tidak perlu berada di dalam bulatan untuk masuk. Pembelajaran tidak pernah berhenti dan saya pasti tidak lama lagi kami akan mempunyai amalan terbaik yang berbeza berdasarkan kegagalan dan kejayaan yang akan kami alami. Mereka dijamin.

Akhirnya, saya ingin menulis tentang bagaimana perisian memakan dunia dan bagaimana JavaScript memakan perisian ... ada perkara yang hebat seperti siaran standard tahunan, banyak dan banyak modul NPM, alat dan persidangan ... tetapi sebaliknya saya akan menyelesaikan dengan kata -kata yang berhati -hati.

Saya melihat bagaimana semakin banyak orang mengejar kerangka atau bahasa baru yang akan datang. Ia adalah sindrom objek berkilat. Mereka belajar perpustakaan baru setiap minggu dan rangka kerja baru setiap bulan. Mereka secara paksa memeriksa Twitter, Reddit, Hacker News dan JS Weekly. Mereka menggunakan tahap aktiviti yang luar biasa di dunia JavaScript untuk menunda -nunda. Mereka mempunyai sejarah GitHub awam kosong.

Pembelajaran perkara -perkara baru adalah baik tetapi jangan mengelirukan untuk membina barangan. Apa yang penting dan apa yang membayar gaji anda sebenarnya membina sesuatu. Berhenti kejuruteraan. Anda tidak membina Facebook seterusnya. Janji vs Generators vs. Async menunggu adalah moot untuk saya, kerana pada masa seseorang menjawab benang dalam perbincangan, saya sudah menulis panggilan balik saya (dan menggunakan coffeescript untuk melakukannya 2x lebih cepat daripada di biasa ES5/6/7! ).

Amalan terbaik terakhir adalah menggunakan amalan terbaik dan yang terbaik adalah untuk menguasai asas -asas. Baca kod sumber, cuba perkara baru dalam kod dan yang paling penting menulis banyak kod sendiri. Sekarang, pada ketika ini, berhenti membaca dan pergi kod kapal yang penting!

dan sekiranya jawatan ini tidak mencukupi di sini adalah lebih banyak bacaan pada amalan nod terbaik:

• https://blog.risingstack.com/nodejs-at-scale-npm-best-cractices
• https://devcenter.heroku.com/articles/node-best-practices
• https://blog.risingstack.com/node-js-best-cractices
• https://expressjs.com/en/advanced/best-practice-performance.html
• https://www.codementor.io/nodejs/tutorial/nodejs-best-practices

Soalan Lazim (Soalan Lazim) di Node.js Amalan Terbaik

Apakah beberapa amalan terbaik yang paling penting untuk pembangunan Node.js? Ini termasuk menggunakan pengaturcaraan asynchronous, yang membolehkan operasi tidak menyekat dan meningkatkan prestasi. Ia juga penting untuk mengendalikan kesilapan dengan betul untuk mengelakkan kemalangan aplikasi. Amalan terbaik lain termasuk menggunakan linter untuk menguatkuasakan kualiti kod, menggunakan pembolehubah persekitaran untuk konfigurasi, dan menulis modul kecil untuk memastikan asas anda boleh diurus dan difahami. 🎜> Terdapat beberapa cara untuk meningkatkan prestasi aplikasi Node.js anda. Salah satu kaedah yang paling berkesan ialah menggunakan modul kluster, yang membolehkan anda membuat proses kanak -kanak yang semua port pelayan saham. Ini dapat meningkatkan prestasi aplikasi anda dengan ketara dengan membenarkannya mengendalikan lebih banyak permintaan secara serentak. Di samping itu, anda boleh menggunakan alat seperti PM2 untuk mengurus dan memantau aplikasi Node.js anda, yang dapat membantu anda mengenal pasti dan menangani isu -isu prestasi. >

Beberapa kesilapan yang biasa untuk dielakkan apabila membangun dengan node.js termasuk menyekat gelung acara, tidak mengendalikan kesilapan dengan betul, dan tidak menggunakan alat seperti linter untuk menguatkuasakan kualiti kod. Menyekat gelung acara boleh membawa kepada isu -isu prestasi, kerana ia menghalang operasi lain daripada dilaksanakan. Tidak mengendalikan kesilapan dengan betul boleh menyebabkan kemalangan aplikasi, sementara tidak menggunakan linter boleh menyebabkan kualiti kod yang tidak konsisten dan bug yang berpotensi.

bagaimana saya dapat memastikan bahawa aplikasi Node.js saya selamat?

Memastikan keselamatan aplikasi Node.js anda melibatkan beberapa amalan terbaik. Ini termasuk menggunakan HTTPS untuk komunikasi yang selamat, mengesahkan dan membersihkan input pengguna untuk mengelakkan serangan suntikan, dan menggunakan tajuk keselamatan untuk melindungi daripada kelemahan web yang sama. Ia juga penting untuk memastikan kebergantungan anda terkini, kerana kebergantungan yang sudah lapuk boleh mengandungi kelemahan keselamatan yang diketahui. Pembangunan node.js, dan terdapat beberapa amalan terbaik untuk diikuti. Ini termasuk ujian unit menulis untuk menguji komponen individu aplikasi anda, ujian integrasi untuk menguji bagaimana komponen ini berinteraksi, dan ujian akhir-ke-akhir untuk menguji aplikasi anda secara keseluruhan. Ia juga penting untuk menggunakan sistem integrasi berterusan (CI) untuk menjalankan ujian anda secara automatik apabila perubahan dibuat ke pangkalan kod anda. Node.js biasanya dilakukan menggunakan NPM, Pengurus Pakej Lalai untuk Node.js. Adalah penting untuk menentukan versi tepat kebergantungan anda dalam fail pakej.json anda untuk memastikan aplikasi anda berfungsi seperti yang diharapkan. Anda juga harus mengemas kini kebergantungan anda secara kerap untuk mendapat manfaat daripada pembetulan pepijat dan patch keselamatan.

Apakah beberapa amalan terbaik untuk pengendalian ralat dalam node.js? Pembangunan JS. Amalan terbaik termasuk menggunakan blok cuba/menangkap untuk menangkap kesilapan segerak, menggunakan panggilan balik pertama ralat untuk mengendalikan kesilapan tak segerak, dan menggunakan mekanisme pengendalian ralat terpusat untuk mengendalikan semua kesilapan di satu tempat. Ia juga penting untuk log kesilapan untuk tujuan debug dan untuk bertindak balas kepada pelanggan dengan mesej ralat yang sesuai.

Bagaimana saya dapat memastikan kualiti kod dalam node.js? melibatkan beberapa amalan terbaik. Ini termasuk menggunakan linter untuk menguatkuasakan kualiti kod, berikutan gaya pengekodan yang konsisten, dan ujian menulis untuk menangkap bug awal. Ia juga penting untuk menggunakan kawalan versi (seperti Git) untuk menjejaki perubahan pada asas kod anda dan untuk melakukan ulasan kod untuk menangkap isu -isu yang berpotensi. Aplikasi Node.js boleh dicapai dalam beberapa cara. Satu kaedah biasa ialah menggunakan modul kluster untuk membuat proses kanak -kanak yang berkongsi port pelayan, yang membolehkan aplikasi anda mengendalikan lebih banyak permintaan secara serentak. Anda juga boleh menggunakan pengimbangan beban untuk mengedarkan trafik rangkaian masuk ke pelbagai pelayan, dan skala mendatar (menambah lebih banyak mesin) atau penskalaan menegak (menambah lebih banyak sumber ke mesin tunggal) bergantung kepada keperluan anda.

Apakah beberapa amalan terbaik untuk menggunakan aplikasi Node.js? Ini termasuk menggunakan pembolehubah persekitaran untuk konfigurasi, menggunakan pengurus proses seperti PM2 untuk menguruskan aplikasi anda, dan menggunakan sistem integrasi berterusan (CI) untuk menggunakan aplikasi anda secara automatik apabila perubahan dibuat ke codebase anda. Ia juga penting untuk memantau aplikasi anda untuk mengenal pasti dan menangani isu -isu prestasi.

Atas ialah kandungan terperinci 10 Node.js Amalan Terbaik: Pencerahan dari Gurus Node. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!