Penjelasan terperinci tentang modul Node.js loading_node.js

JavaScript ialah salah satu bahasa pengaturcaraan yang paling kerap digunakan di dunia Ia adalah bahasa universal dunia Web dan digunakan oleh semua pelayar. Kelahiran JavaScript boleh dikesan kembali ke era Netscape Kandungan terasnya dibangunkan dengan tergesa-gesa untuk bersaing dengan Microsoft dan mengambil bahagian dalam perang pelayar yang sengit pada masa itu. Disebabkan pelepasan pramatang, ia tidak dapat dielakkan menghasilkan beberapa ciri yang tidak begitu baik.

Walaupun masa pembangunannya singkat, JavaScript masih mempunyai banyak ciri berkuasa, kecuali setiap skrip berkongsi ruang nama global.

Setelah halaman web memuatkan kod JavaScript, ia akan disuntik ke dalam ruang nama global dan akan berkongsi ruang alamat yang sama dengan semua skrip lain yang dimuatkan. Ini akan membawa kepada banyak isu keselamatan, konflik dan beberapa masalah biasa sukar untuk dikesan dan sukar untuk diselesaikan.

Tetapi syukur, Node telah menetapkan beberapa spesifikasi untuk JavaScript bahagian pelayan dan juga melaksanakan standard modul CommonJS Dalam piawaian ini, setiap modul mempunyai konteksnya sendiri dan dibezakan daripada modul lain. Ini bermakna modul tidak akan mencemarkan skop global, kerana tidak ada skop global, dan modul tidak akan mengganggu satu sama lain.

Dalam bab ini, kita akan belajar tentang beberapa modul berbeza dan cara memuatkannya.

Memisahkan kod anda kepada satu siri modul yang jelas boleh membantu anda mengawal aplikasi anda Di bawah ini kami akan mempelajari cara membuat dan menggunakan modul anda sendiri.

Ketahui cara Node memuatkan modul

Dalam Node, modul boleh dirujuk mengikut laluan fail atau nama modul Jika modul bukan teras dirujuk mengikut nama, Node akhirnya akan memetakan nama modul ke laluan fail modul yang sepadan. Modul teras yang mengandungi fungsi teras akan dimuatkan apabila Node bermula.

Modul bukan teras termasuk modul pihak ketiga yang dipasang menggunakan NPM (Pengurus Pakej Nod), serta modul tempatan yang dibuat oleh anda atau rakan sekerja anda.

Setiap modul yang diimport oleh skrip semasa akan mendedahkan satu set API awam kepada pengaturcara Sebelum menggunakan modul, anda perlu menggunakan fungsi memerlukan untuk mengimportnya, seperti ini:

Salin kod Kod adalah seperti berikut:

var modul = memerlukan(‘nama_modul’)

Kod di atas akan mengimport modul bernama module_name, yang mungkin merupakan modul teras atau modul yang dipasang dengan NPM Fungsi require mengembalikan objek yang mengandungi semua API awam modul. Bergantung pada modul, objek yang dikembalikan mungkin sebarang nilai JavaScript, fungsi atau objek yang mengandungi siri sifat (fungsi, tatasusunan atau sebarang objek JavaScript).

Modul eksport

Sistem modul CommonJS ialah satu-satunya cara untuk berkongsi objek dan fungsi antara fail di bawah Node. Untuk program yang sangat kompleks, anda harus menyusun semula beberapa kelas, objek atau fungsi ke dalam satu siri modul boleh guna semula yang jelas. Kepada pengguna modul, modul hanya mendedahkan kod yang anda tentukan.

Dalam contoh berikut, anda akan mengetahui bahawa terdapat surat-menyurat satu dengan satu antara fail dan modul dalam Node Kami mencipta fail yang dipanggil circle.js, yang hanya mengeksport pembina Circle.

Salin kod Kod adalah seperti berikut:

fungsi Bulatan(x, y, r) {

fungsi r_squared() {

kembalikan Math.pow(r, 2);

}

kawasan fungsi() {

kembalikan Math.PI * r_squared();

}

kembali {kawasan: kawasan};

}

module.exports = Bulatan;

Baris paling penting dalam kod ialah baris terakhir, yang mentakrifkan apa yang dieksport oleh modul. modul ialah pembolehubah khas, yang mewakili modul semasa itu sendiri, dan module.exports ialah objek yang dieksport oleh modul Ia boleh menjadi sebarang objek Dalam contoh ini, kami mengeksport pembina Circle supaya pengguna modul boleh menggunakan Modul ini Kejadian bulatan.

Anda juga boleh mengeksport beberapa objek kompleks module.exports dimulakan sebagai objek kosong Anda boleh mengeksport sebarang kandungan yang anda ingin dedahkan kepada dunia luar sebagai atribut objek module.exports. Sebagai contoh, anda mereka bentuk modul yang mendedahkan satu set fungsi:

Salin kod Kod adalah seperti berikut:

fungsi printA() {

console.log('A');

}

fungsi cetakanB() {

console.log('B');

}

fungsi cetakanC() {

console.log('C');

}

module.exports.printA = printA;

module.exports.printB = printB;

module.exports.pi = Math.PI;

Modul ini mengeksport dua fungsi (printA dan printB) dan nombor (pi) Kod panggilan kelihatan seperti ini:

Salin kod Kod adalah seperti berikut:

var myModule2 = require('./myModule2');

myModule.printA(); // ->

myModule.printB(); // ->

console.log(myModule.pi); // ->

Muat modul

Seperti yang dinyatakan sebelum ini, anda boleh menggunakan fungsi require untuk memuatkan modul Anda tidak perlu risau tentang memanggil memerlukan dalam kod akan menjejaskan ruang nama global, kerana tiada konsep ruang nama global dalam Node. Jika modul wujud dan tiada sintaks atau ralat permulaan, fungsi memerlukan akan mengembalikan objek modul dan anda boleh menetapkan objek ini kepada mana-mana pembolehubah tempatan.

Terdapat beberapa jenis modul, yang boleh dibahagikan secara kasar kepada modul teras, modul tempatan dan modul pihak ketiga yang dipasang melalui NPM Mengikut jenis modul, terdapat beberapa cara untuk merujuk modul pengetahuan ini.

Muat modul teras

Node mempunyai beberapa modul yang disusun ke dalam fail binari, dipanggil modul teras Mereka tidak boleh dirujuk melalui laluan, hanya nama modul. Modul teras mempunyai keutamaan pemuatan tertinggi Walaupun terdapat modul pihak ketiga dengan nama yang sama, modul teras akan dimuatkan terlebih dahulu.

Sebagai contoh, jika anda ingin memuatkan dan menggunakan modul teras http, anda boleh melakukan ini:

Salin kod Kod adalah seperti berikut:         var http = memerlukan('http');

Ini akan mengembalikan objek modul http, yang mengandungi API modul htpp yang ditakrifkan dalam dokumentasi API Node.

Muat modul fail

Anda juga boleh memuatkan modul daripada sistem fail menggunakan laluan mutlak:

Salin kod Kod adalah seperti berikut: var myModule = require('/home/pedro/my_modules/my_module');

Anda juga boleh menggunakan laluan relatif berdasarkan fail semasa:

Salin kod Kod adalah seperti berikut: var myModule = require('../my_modules/my_module');

var myModule2 = memerlukan('./lib/my_module_2');

Perhatikan kod di atas Anda boleh meninggalkan sambungan nama fail Jika Node tidak dapat mencari fail, ia akan cuba mencari semula dengan menambahkan akhiran js selepas nama fail (Nota Penterjemah: Sebenarnya, dalam. Selain js, ​​ia juga akan mencari json dan nod, sila rujuk dokumentasi laman web rasmi untuk butiran), oleh itu, jika terdapat fail yang dipanggil my_module.js dalam direktori semasa, akan terdapat dua kaedah pemuatan berikut :

Salin kod Kod adalah seperti berikut: var myModule = require('./my_module');

var myModule = require('./my_module.js');

Muat modul direktori

Anda juga boleh menggunakan laluan ke direktori untuk memuatkan modul:

Salin kod Kod adalah seperti berikut: var myModule = require('./myModuleDir');

Node akan menganggap bahawa direktori ini ialah pakej modul dan cuba mencari fail definisi pakej package.json dalam direktori ini.

Jika tidak ditemui, Node akan menganggap bahawa titik masuk pakej ialah fail index.js (Nota Penterjemah: Selain index.js, ia juga akan mencari index.node. Fail .node ialah binari pakej pengembangan Node. Lihat dokumentasi rasmi untuk butiran) , mengambil kod di atas sebagai contoh, Node akan cuba mencari fail ./myModuleDir/index.js.

Sebaliknya, jika fail package.json ditemui, Node akan cuba menghuraikannya, mencari atribut utama dalam definisi pakej, dan kemudian menggunakan nilai atribut utama sebagai laluan relatif titik masuk . Dalam contoh ini, jika package.json ditakrifkan seperti berikut:

Salin kod Kod adalah seperti berikut:

                                                        {

"nama" : "Modul saya",

"utama" : "./lib/myModule.js"

            }

Nod akan cuba memuatkan fail ./myModuleDir/lib/myModule.js

Muat daripada direktori node_modules

Jika parameter fungsi memerlukan bukan laluan relatif atau nama modul teras, Node akan mencari dalam subdirektori node_modules bagi direktori semasa Contohnya, dalam kod berikut, Node akan cuba mencari fail./ node_modules/myModule.js:

Salin kod Kod adalah seperti berikut:

var myModule = require('myModule.js');

Jika ia tidak ditemui, Node akan terus mencari dalam folder node_modules bagi direktori peringkat atas Jika ia belum ditemui, ia akan terus mencari dalam direktori peringkat atas sehingga modul yang sepadan ditemui atau direktori akar. dicapai.

Anda boleh menggunakan ciri ini untuk mengurus kandungan atau modul direktori node_modules, tetapi sebaiknya biarkan tugas pengurusan modul kepada NPM (lihat Bab 1 Direktori node_modules tempatan ialah lokasi lalai untuk NPM memasang modul). . Reka bentuk ini Nod dan NPM dipautkan bersama. Biasanya, sebagai pembangun anda tidak perlu terlalu mengambil berat tentang ciri ini, anda hanya boleh menggunakan NPM untuk memasang, mengemas kini dan memadam pakej, dan ia akan mengekalkan direktori node_modules untuk anda

Modul cache

Modul akan dicache selepas pemuatan pertama berjaya, iaitu, jika nama modul diselesaikan ke laluan fail yang sama, maka setiap panggilan untuk memerlukan('myModule') akan mengembalikan modul yang sama.

Sebagai contoh, terdapat modul yang dipanggil my_module.js, yang mengandungi kandungan berikut:

Salin kod Kod adalah seperti berikut:

console.log('module my_module initializing...');

module.exports = function() {

console.log('Hai!');

};

console.log('my_module dimulakan.');

Kemudian muatkan modul dengan kod berikut:

Salin kod Kod adalah seperti berikut:

var myModuleInstance1 = memerlukan('./my_module');

Ia menghasilkan output berikut:

Salin kod Kod adalah seperti berikut:

modul my_module memulakan...

my_module dimulakan

Jika kita mengimportnya dua kali:

Salin kod Kod adalah seperti berikut:

var myModuleInstance1 = memerlukan('./my_module');

var myModuleInstance2 = memerlukan('./my_module');

Keluaran masih:

Salin kod Kod adalah seperti berikut:

modul my_module memulakan...

my_module dimulakan

Dalam erti kata lain, kod permulaan modul hanya dilaksanakan sekali. Apabila anda membina modul anda sendiri, pastikan anda memberi perhatian khusus kepada ciri ini jika kod permulaan modul mengandungi kod yang mungkin menghasilkan kesan sampingan.

Ringkasan

Node membatalkan skop global lalai JavaScript dan menggunakan sistem modul CommonJS supaya anda boleh menyusun kod anda dengan lebih baik dan mengelakkan banyak isu keselamatan dan pepijat. Anda boleh menggunakan fungsi memerlukan untuk memuatkan modul teras, modul pihak ketiga atau memuatkan modul anda sendiri daripada fail dan direktori

Anda juga boleh menggunakan laluan relatif atau laluan mutlak untuk memuatkan modul bukan teras Jika anda meletakkan modul dalam direktori node_modules atau untuk modul yang dipasang dengan NPM, anda juga boleh terus menggunakan nama modul untuk memuatkan.

Nota Penterjemah:

Adalah disyorkan bahawa pembaca membaca bab modul dokumen rasmi Saya secara peribadi merasakan bahawa ia lebih jelas dan jelas daripada pengarang Ia juga melampirkan contoh yang sangat mewakili, yang akan sangat membantu dalam memahami pemuatan modul Node. Mari kita petik contoh itu:

Salin kod Kod adalah seperti berikut:

Gunakan require(X) untuk memuatkan modul di bawah laluan Y

1. Jika X ialah modul teras,

a. Muatkan dan kembalikan modul teras

b. Tamat

2. Jika X bermula dengan './' atau '/' atau '../'

a. LOAD_AS_FILE(Y X)

b. LOAD_AS_DIRECTORY(Y X)

3. MODUL_NODE_MODUL(X, nama(Y))

4. Pengecualian lontaran: "tidak ditemui"

MUAT_SEBAGAI_FAIL(X)

1. Jika X ialah fail, muatkan X sebagai skrip JavaScript dan tamatkan selepas memuatkan

2. Jika X.js ialah fail, muatkan X.js sebagai skrip JavaScript dan tamatkan selepas memuatkan

3. Jika X.node ialah fail, muatkan X.node sebagai pemalam binari Nod dan tamatkan selepas pemuatan selesai

LOAD_AS_DIRECTORY(X)

1. Jika fail X/package.json wujud,

a. Parse X/package.json, dan cari medan "utama".

b. Satu lagi M = X (nilai medan utama)

c. LOAD_AS_FILE(M)

2. Jika fail X/index.js wujud, muatkan X/index.js sebagai skrip JavaScript dan tamatkan selepas memuatkan

3. Jika fail X/index.node wujud, muatkan X/index.node sebagai pemalam binari Nod dan tamatkan selepas pemuatan selesai

LOAD_NODE_MODULES(X, START)

1. Juga DIRS=NODE_MODULES_PATHS(START)

2. Lakukan operasi berikut untuk setiap DIR direktori di bawah DIRS:

a. LOAD_AS_FILE(DIR/X)

b. LOAD_AS_DIRECTORY(DIR/X)

NODE_MODULES_PATHS(START)

1. Satu lagi BAHAGIAN = pembahagian laluan(MULA)

2. Satu lagi ROOT = indeks contoh pertama "node_modules" dalam BAHAGIAN, atau 0

3. I = kiraan BAHAGIAN - 1

4 lagi DIRS = []

5. manakala saya >

a. Jika PARTS[I] = "node_modules", teruskan operasi seterusnya, jika tidak, ia akan gelung kali seterusnya

c. DIR = gabungan laluan(PARTS[0 .. I] "node_modules")

b. DIRS = DIRS DIR

c. Satu lagi I = I - 1

6. Kembali ke DIRS