4 JS Essentials Node.js Pembangun Mesti Tahu_node.js

Artikel ini meringkaskan 4 perkara penting Node.js untuk pembangun.

1. Tidak menyekat atau tak segerak

Memandangkan Node.js ialah rangka kerja sebelah pelayan, salah satu tugas utamanya ialah mengendalikan permintaan penyemak imbas. Dalam sistem I/O tradisional, setiap permintaan dikeluarkan selepas permintaan sebelumnya tiba. Jadi ini dipanggil menyekat I/O. Pelayan akan menyekat permintaan lain untuk memproses permintaan semasa, menyebabkan penyemak imbas menunggu.

Node.js tidak mengendalikan I/O dengan cara ini. Jika permintaan mengambil masa yang lama untuk diproses, Node.js akan menghantar permintaan ke gelung peristiwa dan meneruskan memproses permintaan seterusnya dalam timbunan panggilan. Apabila permintaan tertunda diproses, ia memberitahu Node.js dan penyemak imbas bertindak balas.

Yang berikut menggunakan contoh untuk menggambarkan.

Menyekat I/O

// take order for table 1 and wait...
var order1 = orderBlocking(['Coke', 'Iced Tea']);
// once order is ready, take order back to table.
serveOrder(order1);
// once order is delivered, move on to another table.
// take order for table 2 and wait...
var order2 = orderBlocking(['Coke', 'Water']);
// once order is ready, take order back to table.
serveOrder(order2);
// once order is delivered, move on to another table.
// take order for table 3 and wait...
var order3 = orderBlocking(['Iced Tea', 'Water']);
// once order is ready, take order back to table.
serveOrder(order3);
// once order is delivered, move on to another table.

Dalam contoh restoran ini, pelayan menerima arahan menu, menunggu hidangan diproses, dan kemudian membawa makanan ke meja selepas hidangan diproses. Sementara pelayan menunggu makanannya diproses, dia akan menolak tempahan menu pelanggan lain.

I/O tidak menyekat

// take order for table 1 and move on...
orderNonBlocking(['Coke', 'Iced Tea'], function(drinks){
 return serveOrder(drinks);
});
// take order for table 2 and move on...
orderNonBlocking(['Beer', 'Whiskey'], function(drinks){
 return serveOrder(drinks);
});
// take order for table 3 and move on...
orderNonBlocking(['Hamburger', 'Pizza'], function(food){
 return serveOrder(food);
});

Dalam mod tidak menyekat, pelayan akan memaklumkan chef arahan menu yang telah diterimanya, dan kemudian menerima arahan untuk meja seterusnya. Apabila makanan meja pertama diproses, dia akan melayan tetamu di meja itu dan kemudian terus menerima arahan daripada tetamu lain. Dengan cara ini, pelayan tidak akan membuang masa dengan menyekat arahan.

2. Prototaip

Prototaip ialah konsep yang kompleks dalam JS. Dalam bahasa mekanisme pewarisan biasa seperti Java atau C++, untuk mencapai penggunaan semula kod, anda mesti membuat kelas dahulu dan kemudian menjana objek melaluinya atau menjana objek melalui sambungan kelas. Tetapi tidak ada konsep kelas yang serupa dalam JS. Selepas mencipta objek dalam JS, anda perlu memanjangkan objek atau mencipta objek baharu melaluinya. Ini dipanggil warisan prototaip.

Setiap objek JS disambungkan ke objek prototaip dan mewarisi sifat objek tersebut. Setiap objek dikaitkan dengan JS Object.prototype yang telah ditetapkan. Jika anda mencari sifat objek melalui obj.propName atau obj['propName'> tetapi carian gagal, anda boleh cuba mencari melalui obj.hasOwnProperty('propName'). objek. Jika harta itu tidak wujud dalam rantaian prototaip, nilai yang tidak ditentukan akan dikembalikan.

Mari kita ilustrasikan dengan contoh berikut:

if (typeof Object.create !== 'function') {
  Object.create = function (o) {
    var F = function () {};
    F.prototype = o;
    return new F();
  };
var otherPerson = Object.create(person);

Apabila anda mencipta objek baharu, anda mesti memilih objek berasaskan prototaip. Di sini, kami telah menambah kaedah cipta pada fungsi objek. Kaedah cipta mencipta objek berdasarkan objek lain dan menghantarnya sebagai parameter.

Apabila kita menukar objek baharu, prototaipnya kekal tidak berubah. Walau bagaimanapun, apabila kita menukar objek prototaip, perubahan itu mempengaruhi semua objek berdasarkan prototaip itu.

3. Modul

Jika anda pernah menggunakan pakej dalam Java, komponen Node.js adalah serupa. Jika tidak, jangan risau; komponen sebenarnya adalah fail JS yang mudah digunakan untuk melaksanakan fungsi tertentu. Tujuan corak komponen adalah untuk memudahkan kerja anda. Untuk menggunakan komponen, anda perlu mengimport fail JS sama seperti anda mengimport pakej dalam JAVA. Terdapat dua jenis komponen dalam Node.js

Modul Teras - Modul teras pra-disusun bersama dengan perpustakaan Node.js. Tujuannya adalah untuk membuka fungsi yang sering digunakan oleh pengaturcara dan mengelakkan pertindihan kerja. Komponen teras biasa termasuk HTTP, URL, ACARA, SISTEM FAIL, dsb.

Modul Ditentukan Pengguna - Modul yang ditakrifkan pengguna ialah komponen yang disediakan kepada pengguna untuk melaksanakan fungsi tertentu. Apabila komponen teras tidak mencukupi untuk memenuhi keperluan pengaturcara, komponen tersuai boleh berguna.

Komponen diekstrak melalui fungsi yang diperlukan. Jika ini ialah komponen teras, parameternya ialah nama komponen. Jika ini adalah komponen yang ditentukan pengguna, parameternya ialah laluan komponennya dalam sistem fail. Contohnya:

// extract a core module like this
var http = require('http);
// extract a user defined module like this
var something = require('./folder1/folder2/folder3/something.js');

4. 回调（Callbacks）

在JS中，函数是第一类对象。也就是说你可以像对常规对象那样对函数进行所有操作。例如指派函数到一个变量，把这些作为参数传给方法，把它们声明为对象的属性，甚至是把它们从函数里返回。

回调在JS中是异步函数，可以作为参数传递给其它函数或从其它函数里执行或返回而后再执行。这是回调的基本概念。

当我们把一个回调函数作为参数传递给另外的函数时，我们传递的仅仅是函数的定义；换言之，我们不会知道回调函数的执行时间。这完全依赖于回调函数机制。它会在稍后某个时间点进行回调调用。这是Node.js的非阻塞或异步行为的基本概念，可用下例进行说明：

setTimeout(function() {
  console.log("world");
}, 2000)
console.log("hello");

这是一个最简单的调用。我们把一个匿名函数作为参数进行传递，作用是为setTimeout函数进行控制台的输出记录登记。因为这仅仅是个函数定义，我们不知道函数何时会被执行。这取决于setTimeout函数的second参数，即2S后。

首先，second记录语句记录了对控制台的输出，2S后，在回调函数中的记录语句记录了输出的内容。

// output
hello
world

写在最后

以上4点对Node.js开发者来说是要彻底理解和掌握的，建议多动手来好好体会这4个要点的含义。