5 Tips & Trik Meningkatkan Performa Aplikasi Node.js

Hello, Spirit of learning!!! Tahukah kamu apa itu Node.js? Node.js adalah lingkungan runtime yang dirancang untuk menjalankan JavaScript di luar peramban (browser). Dengan Node.js, kamu dapat mengembangkan aplikasi berbasis server menggunakan JavaScript. Kamu juga dapat membangun aplikasi jaringan dan server-side yang real-time dan scalable. Jika kamu tertarik dengan pengembangan web menggunakan JavaScript, Node.js adalah pilihan yang sangat baik! 🚀

Mari kita jelajahi 5 Tips & Trik Meningkatkan Performa Aplikasi Node.js yang cepat dan efisien!!!

1. Hindari Memblokir Event Loop

Event loop adalah mekanisme yang memungkinkan Node.js untuk menangani banyak permintaan secara asinkron. Kita harus menghindari melakukan operasi yang berat atau lama di dalam event loop, karena akan menghambat proses lainnya. Node.js dirancang untuk menangani operasi-asinkron dengan efisien, menggunakan event loop untuk mengelola tugas tanpa memblokir. Sebagai gantinya, kita dapat menggunakan teknik seperti async/await, promise, atau callback untuk menjalankan operasi tersebut di luar event loop.

Untuk menghindari memblokir event loop, Kamu dapat:

1. Menggunakan fungsi-asinkron sebanyak mungkin.
2. Pindahkan tugas yang intensif CPU ke thread pekerja terpisah menggunakan modul worker_threads.

const { Worker, isMainThread, parentPort } = require('worker_threads');

if (isMainThread) {
  // Jika berada di thread utama
  const worker = new Worker(__filename);

  // Mendengarkan pesan dari worker
  worker.on('message', (result) => {
    console.log('Result from worker: ', result);
  });

  // Mengirim pesan ke worker untuk melakukan tugas CPU-intensif
  worker.postMessage('Perform CPU-intensive task');
} else {
  // Jika berada di worker thread
  parentPort.on('message', (message) => {
    // Mensimulasikan tugas CPU-intensif
    for (let i = 0; i < 1e9; i++);

    // Mengirim pesan kembali ke thread utama bahwa tugas selesai
    parentPort.postMessage('Task completed');
  });
}

2. Gunakan Caching untuk Meningkatkan Waktu Respons Caching

• 

Caching adalah teknik yang memungkinkan kita untuk menyimpan data yang sering digunakan di dalam memori atau penyimpanan eksternal. Dengan caching, kita dapat mengurangi waktu akses ke sumber daya yang lambat, seperti database atau API eksternal. Kita dapat menggunakan modul seperti redis, cached, atau node-cache untuk mengimplementasikan caching di Node.js.

Berikut adalah contoh cache dalam memori:

const http = require('http');
const data = require('./data.json');
const cache = {};

http.createServer((req, res) => {
  // Mengambil URL permintaan sebagai kunci untuk cache
  const key = req.url;

  // Mengecek apakah data sudah ada di dalam cache
  if (cache[key]) {
    // Jika sudah ada, langsung mengirimkan data dari cache sebagai respons
    res.end(cache[key]);
  } else {
    // Jika data belum ada di cache
    // Memproses data (dalam contoh ini, disimulasikan dengan processData)
    const result = processData(data);

    // Menyimpan hasil pemrosesan ke dalam cache
    cache[key] = result;

    // Mengirimkan hasil pemrosesan sebagai respons
    res.end(result);
  }
}).listen(8000);

Jika kamu lebih memilih untuk menggunakan redis berikut ini contoh penerapannya :

const http = require('http');
const redis = require('redis');
const client = redis.createClient();

// Menangani kesalahan koneksi ke Redis
client.on('error', (err) => {
  console.error('Error:', err);
});

// Membuat server HTTP
http.createServer((req, res) => {
  // Menggunakan URL permintaan sebagai kunci untuk Redis
  const key = req.url;

  // Mengambil data dari Redis dengan kunci tertentu
  client.get(key, (err, result) => {
    // Menangani kesalahan saat mengambil data dari Redis
    if (err) {
      console.error(err);
      res.end();
      return;
    }

    // Jika data sudah ada di Redis, mengirimkan data tersebut sebagai respons
    if (result) {
      res.end(result);
    } else {
      // Jika data belum ada di Redis
      // Memproses data (dalam contoh ini, disimulasikan dengan processData)
      const newData = processData();

      // Menyimpan hasil pemrosesan ke Redis dengan kunci tertentu
      client.set(key, newData);

      // Mengirimkan hasil pemrosesan sebagai respons
      res.end(newData);
    }
  });
}).listen(8000);

3. Gunakan Kompresi untuk Mengurangi Payload Respons

Kompresi adalah teknik yang memungkinkan kita mengurangi ukuran data yang dikirim dari server ke klien. Dengan kompresi, kita dapat meningkatkan kecepatan dan efisiensi transfer data, serta menghemat bandwidth. Mengompresi respons server kita dapat secara signifikan mengurangi ukuran data yang dikirim ke klien, sehingga menghasilkan waktu respons yang lebih cepat dan penggunaan bandwidth yang lebih rendah. Kita dapat menggunakan middleware kompresi dengan Express.js untuk mengaktifkan kompresi gzip.

Pertama kita install compression package:

npm install compression

Kemudian, kita tambahkan middleware ke aplikasi Express.js:

// Mengimpor modul Express untuk membuat server web
const express = require('express');

// Mengimpor modul Compression untuk mengompresi respons HTTP
const compression = require('compression');

// Membuat objek aplikasi Express
const app = express();

// Menggunakan middleware Compression untuk mengompresi respons
app.use(compression());

// Menangani permintaan GET pada route utama ('/')
app.get('/', (req, res) => {
  // Mengirim respons 'Hello, World!' ke klien
  res.send('Hello, World!');
});

// Menjalankan server pada port 8000
app.listen(8000);

4. Optimalkan Parsing dan Stringifikasi JSON

Parsing dan stringifikasi JSON adalah proses yang mengubah data JSON menjadi objek JavaScript dan sebaliknya. Proses ini dapat memakan waktu dan sumber daya yang cukup besar, terutama jika data JSON yang ditangani sangat besar atau kompleks. Kita dapat menggunakan modul seperti fast-json-parse, fast-json-stringify, atau json-stream untuk mengoptimalkan parsing dan stringifikasi JSON di Node.js.

Pertama kita install libraries:

npm install fast-json-parse fast-json-stringify

Kemudian tambahkan kode berikut :

// Mengimpor modul FastJsonParse untuk parsing JSON dengan cepat
const FastJsonParse = require('fast-json-parse');

// Mengimpor modul fast-json-stringify untuk mengonversi objek JavaScript ke JSON dengan cepat
const fastJsonStringify = require('fast-json-stringify');

// JSON string yang akan di-parse
const jsonString = '{"foo": "bar"}';

// Membuat instance FastJsonParse dengan JSON string
const jsonParser = new FastJsonParse(jsonString);

// Mendapatkan hasil parsing dari instance FastJsonParse
const result = jsonParser.value;

// Konfigurasi schema untuk fast-json-stringify
const stringify = fastJsonStringify({ type: 'object', properties: { foo: { type: 'string' } } });

// Menggunakan fast-json-stringify untuk mengonversi objek JavaScript ke JSON
const jsonStringified = stringify({ foo: 'bar' });

5. Gunakan Linter dan Formatter untuk Kualitas Kode yang Konsisten

Linter dan formatter adalah alat yang membantu kita dalam menulis kode yang rapi, bersih, dan konsisten. Linter dapat mendeteksi dan memperbaiki kesalahan sintaks, gaya, atau logika di kode yang telah kita tulis. Formatter dapat mengatur dan memformat kode sesuai dengan aturan yang telah ditentukan. Kita dapat menggunakan modul seperti eslint, prettier, atau standard untuk mengimplementasikan linter dan formatter di Node.js.

Pertama-tama kita install ESLint and Prettier:

npm install --save-dev eslint prettier eslint-plugin-prettier eslint-config-prettier

Kemudian, buat file .eslintrc.json di direktori root proyek yang kita buat dan konfigurasikan ESLint dengan plugin Prettier

{
  "extends": ["prettier"],
  "plugins": ["prettier"],
  "rules": {
    "prettier/prettier": "error"
  }
}

Kesimpulan

Pada artikel ini kita telah menjelajahi panduan singkat untuk meningkatkan performa aplikasi Node.js dengan lima tips praktis. Pertama, kita dapat menghindari operasi yang memblokir event loop dengan memanfaatkan teknik seperti async/await atau callback, serta memindahkan tugas CPU-intensif ke worker threads. Selanjutnya, optimalisasi waktu respons dapat dicapai dengan memanfaatkan caching, baik dalam memori atau menggunakan penyimpanan eksternal seperti Redis. Tips ketiga mengajak untuk menggunakan kompresi gzip dengan middleware seperti compression untuk mengurangi ukuran payload respons, meningkatkan efisiensi transfer data, dan menghemat bandwidth. Selain itu, optimalkan parsing dan stringifikasi JSON dengan modul seperti fast-json-parse dan fast-json-stringify. Terakhir, untuk menjaga konsistensi dan kualitas kode, kita dapat menggunakan Linter dan formatter seperti ESLint dan Prettier. Dengan mengikuti tips-tips ini, kita dapat meningkatkan kinerja, responsivitas, dan keberlanjutan kode dalam proyek Node.js.

Apakah kamu tertarik dengan pembahasan mengenai Node.js? Ikuti Rekomendasi Kelas di BuildWithAngga Kelas Online Node JavaScript Dasar | BuildWithAngga dan Kelas Online Membuat Website Voucher Game dengan terintegrasi API VocaGame | BuildWithAngga. Mari kamu dapat berekplorasi bagaimana pembuatan project Node JS untuk meningkatkan skills dan pengalaman kamu dalam development sebuah aplikasi!!!