JavaScript adalah salah satu bahasa pemrograman yang paling sering digunakan di dunia. Ini adalah bahasa umum di dunia web dan digunakan oleh semua browser. Kelahiran JavaScript kembali ke era Netscape, dan konten intinya dengan cepat dikembangkan untuk melawan Microsoft dan berpartisipasi dalam Perang Browser yang sengit pada waktu itu. Karena rilis prematur, beberapa fitur yang buruk dihasilkan.
Meskipun waktu pengembangannya singkat, JavaScript masih memiliki banyak fitur yang kuat, kecuali untuk fitur berbagi namespace global untuk setiap skrip.
Setelah halaman web dimuat dengan kode JavaScript, itu disuntikkan ke namespace global dan akan berbagi ruang alamat yang sama seperti semua skrip yang dimuat lainnya, yang akan mengarah pada banyak masalah keamanan, konflik, dan beberapa masalah umum, membuat bug sulit dilacak dan sulit diselesaikan.
Tapi untungnya, Node telah menetapkan beberapa spesifikasi untuk javascript sisi server dan juga mengimplementasikan standar modul CommonJS. Dalam standar ini, setiap modul memiliki konteksnya sendiri dan dibedakan dari modul lain. Ini berarti bahwa modul tidak akan mencemari ruang lingkup global, karena tidak ada lingkup global sama sekali, dan modul tidak akan saling mengganggu.
Dalam bab ini, kita akan belajar tentang beberapa modul yang berbeda dan cara memuatnya.
Memecah kode menjadi serangkaian modul yang terdefinisi dengan baik dapat membantu Anda mengontrol aplikasi Anda. Di bawah ini kami akan belajar cara membuat dan menggunakan modul Anda sendiri.
Pelajari bagaimana simpul memuat modul
Dalam node, modul dapat direferensikan melalui jalur file atau nama modul. Jika modul non-core dirujuk berdasarkan nama, Node pada akhirnya akan menyinggung nama modul ke jalur file modul yang sesuai. Dan modul inti yang berisi fungsi inti akan dimuat sebelumnya saat node dimulai.
Modul non-inti termasuk modul pihak ketiga yang diinstal menggunakan NPM (Node Package Manager), serta modul lokal yang dibuat oleh Anda atau kolega Anda.
Setiap modul yang diimpor oleh skrip saat ini akan mengekspos satu set API yang terpapar ke programmer. Sebelum menggunakan modul, Anda perlu menggunakan fungsi yang memerlukan untuk mengimpornya, seperti ini:
Salinan kode adalah sebagai berikut:
var module = membutuhkan ('module_name')
Kode di atas akan mengimpor modul bernama module_name. Ini mungkin modul inti atau modul yang diinstal dengan NPM. Fungsi yang membutuhkan mengembalikan objek yang berisi semua API publik dari modul. Bergantung pada modul, objek yang dikembalikan dapat berupa nilai JavaScript apa pun, dapat berupa fungsi, atau objek yang berisi serangkaian atribut (fungsi, array, atau objek JavaScript apa pun).
Modul Ekspor
Sistem modul CommonJS adalah satu -satunya cara untuk berbagi objek dan fungsi antara file di bawah node. Untuk program yang sangat kompleks, Anda harus merekonstruksi beberapa kelas, objek, atau fungsi menjadi serangkaian modul yang dapat digunakan kembali dengan baik. Untuk pengguna modul, modul hanya memperlihatkan kode yang Anda tentukan ke dunia luar.
Dalam contoh berikut, Anda akan memahami bahwa dalam simpul, file dan modul sesuai satu per satu. Kami membuat file yang disebut Circle.js, yang hanya mengekspor konstruktor lingkaran ke luar.
Salinan kode adalah sebagai berikut:
lingkaran fungsi (x, y, r) {
fungsi r_squared () {
return math.pow (r, 2);
}
area fungsi () {
return math.pi * r_squared ();
}
return {Area: Area};
}
Module.Exports = Circle;
Hal terpenting dalam kode adalah baris terakhir, yang mendefinisikan apa yang diekspor modul ke luar. Modul adalah variabel khusus, yang mewakili modul saat ini itu sendiri, dan modul. Exports adalah objek yang diekspor dari modul. Itu bisa menjadi objek apa pun. Dalam contoh ini, kami mengekspor konstruktor lingkaran sehingga pengguna modul dapat menggunakan modul ini untuk membuat instance lingkaran.
Anda juga dapat mengekspor beberapa objek kompleks, modul. Exports diinisialisasi menjadi objek kosong, dan Anda mengekspor apa pun yang ingin Anda ungkapkan ke dunia luar sebagai atribut modul. Objek Exports. Misalnya, Anda merancang modul yang memaparkan satu set fungsi ke luar:
Salinan kode adalah sebagai berikut:
fungsi printa () {
console.log ('a');
}
fungsi printb () {
console.log ('b');
}
fungsi printc () {
console.log ('c');
}
module.exports.printa = printa;
module.exports.printb = printb;
module.exports.pi = math.pi;
Modul ini mengekspor dua fungsi (printa dan printb) dan angka (pi), dan kode panggilan terlihat seperti ini:
Salinan kode adalah sebagai berikut:
var mymodule2 = membutuhkan ('./ mymodule2');
myModule2.printa (); // -> a
myModule2.printb (); // -> b
console.log (mymodule2.pi); // -> 3.141592653589793
Modul Memuat
Seperti yang disebutkan sebelumnya, Anda dapat menggunakan fungsi yang memerlukan untuk memuat modul, dan jangan khawatir bahwa panggilan yang diperlukan dalam kode akan mempengaruhi namespace global, karena tidak ada konsep namespace global di node. Jika modul ada tanpa sintaks atau kesalahan inisialisasi, fungsi yang memerlukan akan mengembalikan objek modul, dan Anda juga dapat menetapkan objek ini ke variabel lokal apa pun.
Ada beberapa jenis modul yang berbeda, yang dapat dibagi secara kasar menjadi modul inti, modul lokal dan modul pihak ketiga yang dipasang melalui NPM. Menurut jenis modul, ada beberapa cara untuk merujuk ke modul. Mari kita pelajari tentang pengetahuan di bawah ini.
Memuat modul inti
Node memiliki beberapa modul yang dikompilasi ke dalam file biner, yang disebut modul inti. Mereka tidak dapat dirujuk oleh jalur, dan hanya dapat digunakan dengan nama modul. Modul inti memiliki prioritas pemuatan tertinggi, dan bahkan jika sudah ada modul pihak ketiga dengan nama yang sama, modul inti akan dimuat terlebih dahulu.
Misalnya, jika Anda ingin memuat dan menggunakan modul inti HTTP, Anda dapat melakukan ini:
Salinan kode adalah sebagai berikut:
var http = membutuhkan ('http');
Ini akan mengembalikan objek yang berisi modul HTTP, yang berisi API dari modul HTTP yang ditentukan dalam dokumentasi API simpul.
Memuat modul file
Anda juga dapat menggunakan jalur absolut untuk memuat modul dari sistem file:
Salinan kode adalah sebagai berikut:
var mymodule = membutuhkan ('/home/pedro/my_modules/my_module');
Anda juga dapat menggunakan jalur relatif berdasarkan file saat ini:
Salinan kode adalah sebagai berikut:
var mymodule = membutuhkan ('../ my_modules/my_module');
var mymodule2 = membutuhkan ('./ lib/my_module_2');
Perhatikan kode di atas. Anda dapat menghilangkan ekstensi nama file. Jika Node tidak dapat menemukan file ini, Anda akan mencoba menambahkan akhiran JS untuk mencari lagi setelah nama file (Catatan Penerjemah: Faktanya, selain JS, Anda juga akan mencari JSON dan Node. Untuk detailnya, Anda dapat melihat dokumentasi situs web resmi). Oleh karena itu, jika file yang disebut my_module.js ada di direktori saat ini, akan ada dua metode pemuatan:
Salinan kode adalah sebagai berikut:
var mymodule = membutuhkan ('./ my_module');
var mymodule = membutuhkan ('./ my_module.js');
Memuat Modul Direktori
Anda juga dapat menggunakan jalur direktori untuk memuat modul:
Salinan kode adalah sebagai berikut:
var mymodule = membutuhkan ('./ mymoduledir');
Node akan berasumsi bahwa direktori ini adalah paket modul dan mencoba mencari paket file definisi paket.json di direktori ini.
Jika tidak ditemukan, Node akan mengasumsikan bahwa titik masuk paket adalah file index.js (catatan penerjemah: Selain index.js, itu juga akan mencari index.node, dan file .node adalah paket ekstensi biner node, lihat dokumen resmi untuk detailnya). Kode di atas adalah contoh. Node akan mencoba menemukan file ./mymoduledir/index.js.
Sebaliknya, jika file package.json ditemukan, Node akan mencoba untuk menguraikannya dan mencari atribut utama dalam definisi paket, dan kemudian menggunakan nilai atribut utama sebagai jalur relatif dari titik masuk. Dalam contoh ini, jika package.json didefinisikan sebagai berikut:
Salinan kode adalah sebagai berikut:
{
"Nama": "MyModule",
"Main": "./lib/mymodule.js"
}
Simpul akan mencoba memuat file ./mymoduledir/lib/mymodule.js
Muat dari direktori node_modules
Jika parameter dari fungsi yang diperlukan bukan jalur relatif atau nama modul inti, node akan dicari di subdirektori node_modules dari direktori saat ini. Misalnya, dalam kode berikut, Node akan mencoba menemukan file./node_modules/mymodule.js:
Salinan kode adalah sebagai berikut:
var mymodule = membutuhkan ('mymodule.js');
Jika tidak ditemukan, Node akan terus mencari di folder Node_Modules dari direktori atas. Jika tidak ditemukan, terus cari di direktori atas sampai modul yang sesuai ditemukan atau direktori root tercapai.
Anda dapat menggunakan fitur ini untuk mengelola konten atau modul direktori Node_Modules, tetapi yang terbaik adalah menyerahkan tugas manajemen modul ke NPM (lihat Bab 1). Direktori node_modules lokal adalah lokasi default untuk modul instalasi NPM. Desain ini mengaitkan node dan NPM bersama -sama. Biasanya, sebagai pengembang, Anda tidak perlu terlalu peduli dengan fitur ini. Anda dapat menginstal, memperbarui, dan menghapus paket menggunakan NPM, yang akan membantu Anda mempertahankan direktori Node_Modules.
Modul cache
Modul akan di -cache setelah pemuatan pertama yang berhasil, yaitu, jika nama modul diselesaikan ke jalur file yang sama, maka setiap panggilan untuk memerlukan ('mymodule') akan mengembalikan modul yang persis sama.
Misalnya, ada modul yang disebut my_module.js yang berisi konten berikut:
Salinan kode adalah sebagai berikut:
console.log ('modul my_module inisialisasi ...');
module.exports = function () {
console.log ('hai!');
};
console.log ('my_module diinisialisasi.');
Kemudian gunakan kode berikut untuk memuat modul:
Salinan kode adalah sebagai berikut:
var mymoduleInstance1 = membutuhkan ('./ my_module');
Itu menghasilkan output berikut:
Salinan kode adalah sebagai berikut:
modul my_module inisialisasi ...
my_module diinisialisasi
Jika kita mengimpornya dua kali:
Salinan kode adalah sebagai berikut:
var mymoduleInstance1 = membutuhkan ('./ my_module');
var mymoduleInstance2 = membutuhkan ('./ my_module');
Outputnya masih:
Salinan kode adalah sebagai berikut:
modul my_module inisialisasi ...
my_module diinisialisasi
Dengan kata lain, kode inisialisasi modul hanya dieksekusi sekali. Saat Anda membangun modul sendiri, jika kode inisialisasi modul berisi kode yang mungkin memiliki efek samping, Anda harus memberikan perhatian khusus pada fitur ini.
ringkasan
Node membatalkan ruang lingkup global default JavaScript dan sebaliknya mengadopsi sistem modul CommonJS, sehingga Anda dapat mengatur kode Anda dengan lebih baik dan menghindari banyak masalah keamanan dan bug. Anda dapat menggunakan fungsi yang memerlukan untuk memuat modul inti, modul pihak ketiga, atau memuat modul Anda sendiri dari file dan direktori.
Anda juga dapat menggunakan jalur relatif atau absolut untuk memuat modul non-inti. Jika Anda memasukkan modul di direktori Node_Modules atau untuk modul yang diinstal dengan NPM, Anda juga dapat secara langsung menggunakan nama modul untuk memuat.
Catatan Penerjemah:
Dianjurkan agar pembaca membaca bab modul dari dokumen resmi. Saya pribadi merasa lebih jelas dari penulis. Contoh yang sangat representatif telah dilampirkan, yang akan sangat membantu untuk memahami pemuatan modul simpul. Berikut ini juga dikutip:
Salinan kode adalah sebagai berikut:
Gunakan membutuhkan (x) untuk memuat modul di bawah jalur y
1. Jika x adalah modul inti,
A. Muat dan kembalikan modul inti
B. Akhir
2. Jika X dimulai dengan './' atau '/' atau '../
A. Load_as_file (y + x)
B. Load_as_directory (y + x)
3. LOAD_NODE_MODULES (x, dirname (y))
4. Lempar pengecualian: "tidak ditemukan"
Load_as_file (x)
1. Jika x adalah file, muat x sebagai skrip javascript dan akhiri setelah memuat
2. Jika x.js adalah file, muat x.js sebagai skrip javascript dan akhiri setelah memuat
3. Jika x.node adalah file, muat x.node sebagai plug-in biner simpul dan end setelah pemuatan.
Load_as_directory (x)
1. Jika file x/package.json ada,
A. Parses x/package.json dan temukan bidang "utama".
B. Juga m = x + (nilai bidang utama)
C. Load_as_file (m)
2. Jika file X/Index.js ada, muat x/index.js sebagai skrip JavaScript dan akhiri setelah memuat.
3. Jika file x/index.node ada, muat x/index.node sebagai plug-in biner simpul dan end setelah pemuatan.
Load_node_modules (x, mulai)
1. Juga dirs = node_modules_paths (mulai)
2. Lakukan operasi berikut untuk setiap direktori DIR di bawah dir:
A. Load_as_file (dir/x)
B. Load_as_directory (dir/x)
Node_modules_paths (mulai)
1. Juga bagian = jalur split (mulai)
2. Juga root = indeks instance pertama "node_modules" di bagian, atau 0
3. Juga i = jumlah bagian - 1
4. Dirs = [] juga
5. Sedangkan i> root,
A. Jika bagian [i] = "node_modules" maka operasi tindak lanjut akan berlanjut, jika tidak pada loop berikutnya
C. Dir = path join (bagian [0 .. i] + "node_modules")
B. Dirs = Dirs + Dir
C. Juga i = i - 1
6. Kembali ke Dirs