10 Petua untuk Membuat Aplikasi Node.js Lebih Cepat_node.js

NodeJS ialah penterjemah JavaScript sebelah pelayan yang akan mengubah konsep cara pelayan harus berfungsi. Matlamatnya adalah untuk membantu pengaturcara membina aplikasi yang sangat berskala dan menulis kod yang boleh mengendalikan berpuluh-puluh ribu sambungan serentak kepada satu (dan hanya satu) mesin fizikal.

Node.js sudah pun pantas kerana sifatnya yang dipacu peristiwa dan tak segerak. Walau bagaimanapun, hanya pantas tidak mencukupi dalam rangkaian moden. Jika anda akan menggunakan Node.js untuk membangunkan aplikasi web anda yang seterusnya, maka anda harus melakukan apa sahaja untuk menjadikan aplikasi anda lebih pantas, sangat pantas. Artikel ini akan memperkenalkan 10 petua yang diuji yang boleh meningkatkan aplikasi Node dengan sangat baik. Tanpa berlengah lagi, mari kita lihat satu persatu.

1. Selari

Apabila membuat aplikasi web, anda mungkin perlu memanggil API dalaman beberapa kali untuk mendapatkan pelbagai data. Sebagai contoh, katakan pada halaman Papan Pemuka, anda ingin melaksanakan panggilan berikut:

Maklumat pengguna -getUserProfile().

Aktiviti semasa -getRecentActivity().

Kandungan langganan -getSubscriptions().

Kandungan pemberitahuan -getNotifications().

Untuk mendapatkan maklumat ini, anda harus membuat perisian tengah bebas untuk setiap kaedah dan kemudian memautkannya ke laluan Papan Pemuka. Tetapi masalahnya ialah pelaksanaan kaedah ini adalah linear, dan yang seterusnya tidak akan bermula sehingga yang sebelumnya berakhir. Penyelesaian yang mungkin adalah dengan memanggilnya secara selari.

Seperti yang anda ketahui Node.js sangat pandai memanggil pelbagai kaedah secara selari kerana ketidaksegerakannya. Kita tidak boleh membazirkan sumber kita. Kaedah yang saya nyatakan di atas tidak mempunyai kebergantungan supaya kita boleh melaksanakannya secara selari. Dengan cara ini kita boleh mengurangkan jumlah perisian tengah dan meningkatkan kelajuan dengan banyak.

Kami boleh menggunakan async.js untuk mengendalikan paralelisme, iaitu modul Nod yang digunakan khas untuk menala JavaScript secara tidak segerak. Kod berikut menunjukkan cara menggunakan async.js untuk memanggil berbilang kaedah secara selari:

function runInParallel() {
async.parallel([
getUserProfile,
getRecentActivity,
getSubscriptions,
getNotifications
], function(err, results) {
//This callback runs when all the functions complete
});
}

Jika anda ingin mengetahui lebih lanjut tentang async.js, sila lawati halaman GitHubnya.

2. Tak segerak

Node.js adalah satu benang mengikut reka bentuk. Berdasarkan ini, kod segerak boleh menyumbat keseluruhan aplikasi. Sebagai contoh, kebanyakan API sistem fail mempunyai versi segeraknya. Kod berikut menunjukkan kedua-dua operasi segerak dan tak segerak bagi membaca fail:

// Asynchronous
fs.readFile('file.txt', function(err, buffer) {
var content = buffer.toString();
});
// Synchronous
var content = fs.readFileSync('file.txt').toString();

Tetapi jika anda melakukan operasi menyekat jangka panjang, utas utama akan disekat sehingga operasi ini selesai. Ini sangat mengurangkan prestasi aplikasi anda. Oleh itu, adalah lebih baik untuk memastikan bahawa kod anda menggunakan versi tak segerak API Sekurang-kurangnya, anda harus tidak segerak pada nod prestasi. Selain itu, anda harus berhati-hati apabila memilih modul pihak ketiga. Kerana apabila anda cuba menghapuskan operasi penyegerakan daripada kod anda, panggilan segerak daripada pustaka luaran akan menjadikan semua usaha anda sia-sia dan mengurangkan prestasi aplikasi anda

3. Cache

Jika anda menggunakan beberapa data yang tidak kerap berubah, anda harus cache untuk meningkatkan prestasi. Contohnya, kod berikut ialah contoh mendapatkan siaran terkini dan memaparkannya:

var router = express.Router();
router.route('/latestPosts').get(function(req, res) {
Post.getLatest(function(err, posts) {
if (err) {
throw err;
}
res.render('posts', { posts: posts });
});
});

Jika anda tidak kerap membuat siaran, anda boleh cache senarai siaran dan mengosongkannya selepas satu tempoh masa. Sebagai contoh, kita boleh menggunakan modul Redis untuk mencapai tujuan ini. Sudah tentu, anda mesti memasang Redis pada pelayan anda. Anda kemudiannya boleh menggunakan klien yang dipanggil node_redis untuk menyimpan pasangan kunci/nilai. Contoh berikut menunjukkan cara kami menyimpan siaran:

var redis = require('redis'),
client = redis.createClient(null, null, { detect_buffers: true }),
router = express.Router();
router.route('/latestPosts').get(function(req,res){
client.get('posts', function (err, posts) {
if (posts) {
return res.render('posts', { posts: JSON.parse(posts) });
}
Post.getLatest(function(err, posts) {
if (err) {
throw err;
}
client.set('posts', JSON.stringify(posts)); 
res.render('posts', { posts: posts });
});
});
});

Lihat, mari kita semak cache Redis untuk melihat sama ada terdapat siaran. Jika ada, kami mendapat senarai siaran daripada cache. Jika tidak, kami mendapatkan semula kandungan pangkalan data dan cache hasilnya. Selain itu, selepas tempoh masa tertentu, kami boleh mengosongkan cache Redis supaya kandungan boleh dikemas kini.

4.gzip mampatan

Mendayakan pemampatan gzip boleh memberi impak yang besar pada aplikasi web anda. Apabila penyemak imbas termampat gzip meminta beberapa sumber, pelayan memampatkan respons sebelum mengembalikannya kepada penyemak imbas. Jika anda tidak gzip sumber statik anda, penyemak imbas mungkin mengambil masa yang lebih lama untuk mendapatkannya.

Dalam aplikasi Express, kami boleh menggunakan perisian tengah express.static() terbina dalam untuk mengendalikan kandungan statik. Selain itu, kandungan statik boleh dimampatkan dan diproses menggunakan perisian tengah mampatan. Berikut ialah contoh penggunaan:

var compression = require('compression');
app.use(compression()); //use compression 
app.use(express.static(path.join(__dirname, 'public')));

5.尽量在客户端渲染

现在有超多功能强劲的客户端 MVC/MVVM 框架，比如说 AngularJS, Ember, Meteor, 等等，构建一个单页面应用变得非常简单。基本上，你只要公开一个 API，返回 JSON 响应给客户端就可以了，而不需要在服务端渲染页面。

在客户端，你可以用框架来组织 JSON 然后把它们显示在 UI 上。服务端只发送 JSON 响应可以节省带宽，改善性能，因为你不需要在每个响应里面都返回布局标记了，对吧，你只需要返回纯 JSON，然后在客户端渲染它们。

6.不要在Session存储太多数据

典型的 Express 页面应用， Session 数据默认是保存在内存中的。当你把太多数据保存在 Session 的时候，会导致服务器开销显著增大。所以，要么你切换到别的储存方式来保存 Session 数据，要么尽量减少存储在 Session 中的数据量。

比如说，当用户登录到你的应用的时候，你可以只在 Session 中保存他们的 ID 而不是整个用户数据对象。还有，对于那些你能够从 id 拿到对象的查询，你应该会喜欢用 MongoDB 或者 Redis 来存储 session 数据。

7.优化查询

假设你有个博客，你要在主页上显示最新帖子。你可能会通过 Mongoose 这样取数据:

Post.find().limit(10).exec(function(err, posts) {
//send posts to client
});

不过问题是 Mongoose 的 find() 方法会把对象的所有字段都查询出来，而许多字段在主页上并不要求。比如说，commentsis 保存的是特定帖子的回复。我们不需要显示文章回复，所以我们可以在查询的时候把它给剔除掉。这无疑会提高速度。可以像这样优化上面那条查询：

Post.find().limit(10).exclude('comments').exec(function(err, posts) {
//send posts to client
});

8.用标准的V8方法

集合上的一些操作，比如 map，reduce，和 forEach 不一定支持所有浏览器。我们可以通过前台的库解决部分浏览器兼容性问题。但对于 Node.js，你要确切知道 Google 的 V8 JavaScript 引擎支持哪些操作。这样，你就可以在服务端直接用这些内建方法来操作集合了。

9.在 Node 前面用 Nginx

Nginx 是个微小型轻量 Web 服务器，用它可以降低你的 Node.js 服务器的负载。你可以把静态资源配置到 nginx 上，而不是在 Node 上。你可以在 nginx 上用 gzip 压缩响应，让所有的响应都变得更小。所以，如果你有个正在营运的产品，我觉得你应该会想用 nginx 来改善运行速度的。

10.打包JavaScript

最后，你还可以大大提高页面应用速度，通过把多个 JS 文件打包。当浏览器在页面渲染中碰到 元素的时候会被堵塞，直到拿到这个脚本才继续运行(除非设置了异步属性)。比如，如果你的页面有五个 JavaScript 文件，浏览器会发出五个独立的 HTTP 请求来获取他们。如果把这五个文件压缩打包成一个，整体性能将可以大幅提升。CSS 文件也是一样。你可以用诸如 Grunt/Gulp 这样的编译工具来打包你的资源文件。

通过以上十个方面给大家介绍了Node.js 应用跑得更快的技巧，希望对大家有所帮助！