Node.js adalah runtime JavaScript berbasis V8 Engine yang memungkinkan JavaScript berjalan di sisi server. Dokumentasi ini disusun sebagai panduan lengkap dari dasar hingga lanjutan untuk pemula dan developer menengah.
Sebelum mempelajari Node.js, disarankan memahami dasar JavaScript. Jika belum, silakan baca Sejarah JavaScript & Evolusinya dan Dokumentasi Tag HTML Lengkap.
1. Apa Itu Node.js?
Node.js adalah platform open-source yang memungkinkan eksekusi JavaScript di luar browser. Node.js dirancang untuk membangun aplikasi jaringan yang cepat, scalable, dan efisien.
1.1 Karakteristik Utama Node.js
- Berbasis JavaScript
- Non-blocking I/O
- Event-driven architecture
- Single-threaded dengan event loop
2. Sejarah Singkat Node.js
Node.js pertama kali diperkenalkan oleh Ryan Dahl pada tahun 2009. Tujuannya adalah mengatasi keterbatasan server tradisional yang menggunakan model blocking I/O.
Baca lebih lengkap: Sejarah Node.js dan Perkembangannya.
3. Kegunaan Node.js
- Web server dan REST API
- Real-time application (chat, streaming)
- Backend aplikasi SPA
- Microservices
- CLI tools
4. Arsitektur Node.js
Node.js menggunakan arsitektur event-driven non-blocking yang memungkinkan menangani ribuan koneksi secara bersamaan.
4.1 Event Loop
Event Loop bertugas mengelola eksekusi asynchronous task seperti callback, promise, dan async/await.
console.log("Start");
setTimeout(() => {
console.log("Async Task");
}, 1000);
console.log("End");
5. Single Thread vs Multi Thread
Node.js berjalan pada single thread untuk JavaScript execution, namun memanfaatkan thread pool untuk operasi I/O.
5.1 Kelebihan
- Ringan dan cepat
- Mudah di-scale
5.2 Kekurangan
- Tidak cocok untuk CPU intensive task
6. Instalasi Node.js
Node.js dapat diunduh dari situs resmi: nodejs.org
6.1 Cek Versi Node.js
node -v
npm -v
7. NPM (Node Package Manager)
NPM adalah package manager bawaan Node.js yang digunakan untuk mengelola dependency.
7.1 Inisialisasi Project
npm init -y
7.2 Install Package
npm install express
8. Struktur Folder Project Node.js
project-node/
├── node_modules/
├── package.json
├── package-lock.json
└── index.js
9. File package.json
package.json menyimpan metadata dan dependency project.
{
"name": "project-node",
"version": "1.0.0",
"main": "index.js",
"scripts": {
"start": "node index.js"
}
}
10. Membuat Program Node.js Pertama
console.log("Hello Node.js");
11. Node.js vs PHP
| Node.js | PHP |
|---|---|
| Asynchronous | Synchronous (default) |
| JavaScript | PHP |
| Event-driven | Request-based |
Pelajari juga: Sejarah PHP dan Evolusinya.
12. Kapan Menggunakan Node.js?
- Aplikasi real-time
- API dengan traffic tinggi
- Microservices architecture
13. Kesalahan Umum Pemula
- Mengabaikan error handling
- Menjalankan task berat di main thread
- Tidak memahami async/await
14. Ringkasan Ke 1
Pada bagian ini, Anda telah memahami konsep dasar Node.js, arsitektur, serta lingkungan pengembangannya. Bagian selanjutnya akan membahas module, filesystem, dan HTTP server.
15. Core Module pada Node.js
Node.js memiliki core module bawaan yang dapat digunakan tanpa instalasi tambahan. Core module ini menyediakan fitur penting seperti file system, HTTP server, path, dan informasi sistem.
15.1 Menggunakan Core Module
const fs = require('fs');
const http = require('http');
16. Module System pada Node.js
Node.js menggunakan CommonJS module system. Setiap file JavaScript dianggap sebagai satu module.
16.1 Export Module
// math.js
function tambah(a, b) {
return a + b;
}
module.exports = tambah;
16.2 Import Module
// index.js
const tambah = require('./math');
console.log(tambah(2, 3));
17. File System (fs)
Module fs digunakan untuk membaca dan menulis file di server.
17.1 Membaca File
const fs = require('fs');
fs.readFile('data.txt', 'utf8', (err, data) => {
if (err) throw err;
console.log(data);
});
17.2 Menulis File
fs.writeFile('output.txt', 'Hello Node.js', err => {
if (err) throw err;
console.log('File berhasil dibuat');
});
18. Path Module
Path module membantu mengelola path file agar konsisten di berbagai OS.
const path = require('path');
console.log(path.basename(__filename));
console.log(path.dirname(__filename));
console.log(path.extname(__filename));
19. OS Module
OS module digunakan untuk mendapatkan informasi sistem operasi.
const os = require('os');
console.log(os.platform());
console.log(os.cpus().length);
console.log(os.totalmem());
20. HTTP Module
HTTP module memungkinkan pembuatan web server tanpa framework tambahan.
20.1 Membuat HTTP Server
const http = require('http');
const server = http.createServer((req, res) => {
res.writeHead(200, { 'Content-Type': 'text/plain' });
res.end('Hello from Node.js Server');
});
server.listen(3000, () => {
console.log('Server berjalan di http://localhost:3000');
});
21. Routing Sederhana
Routing dasar dapat dilakukan dengan memeriksa URL request.
const server = http.createServer((req, res) => {
if (req.url === '/') {
res.end('Home Page');
} else if (req.url === '/about') {
res.end('About Page');
} else {
res.writeHead(404);
res.end('404 Not Found');
}
});
22. Handling Request Method
if (req.method === 'GET') {
res.end('GET request');
}
23. Streaming Data
Node.js mendukung streaming untuk menangani data besar secara efisien.
const stream = fs.createReadStream('bigfile.txt');
stream.pipe(res);
24. Error Handling Dasar
process.on('uncaughtException', err => {
console.error('Error:', err.message);
});
25. Hubungan Node.js dengan Database
Node.js sering digunakan bersama MySQL, MongoDB, dan PostgreSQL.
26. Ringkasan Ke 2
Pada bagian ini, Anda telah mempelajari core module Node.js, pengelolaan file, path, sistem, serta pembuatan HTTP server dasar. Bagian berikutnya akan membahas framework Express.js dan middleware.
27. Pengenalan Express.js
Express.js adalah framework minimalis untuk Node.js yang mempermudah pembuatan web server dan REST API.
27.1 Instalasi Express.js
npm install express
27.2 Server Express Pertama
const express = require('express');
const app = express();
app.get('/', (req, res) => {
res.send('Hello Express');
});
app.listen(3000, () => {
console.log('Server berjalan di http://localhost:3000');
});
28. Routing pada Express.js
Routing menentukan bagaimana aplikasi merespons request ke URL tertentu.
28.1 Basic Routing
app.get('/about', (req, res) => {
res.send('Halaman About');
});
28.2 Routing Method
app.post('/login', (req, res) => {
res.send('Login berhasil');
});
29. Middleware pada Express.js
Middleware adalah fungsi yang dieksekusi sebelum request mencapai handler.
29.1 Middleware Global
app.use((req, res, next) => {
console.log('Request diterima');
next();
});
29.2 Middleware Built-in
app.use(express.json());
app.use(express.urlencoded({ extended: true }));
30. Static File
app.use(express.static('public'));
31. Request & Response Object
Express menyediakan object req dan res untuk mengelola request dan response.
31.1 Mengambil Parameter
app.get('/user/:id', (req, res) => {
res.send('User ID: ' + req.params.id);
});
31.2 Query String
app.get('/search', (req, res) => {
res.send(req.query.q);
});
32. REST API Dasar
REST API memungkinkan komunikasi antara client dan server menggunakan HTTP.
32.1 GET
app.get('/api/users', (req, res) => {
res.json([{ id: 1, nama: 'Andi' }]);
});
32.2 POST
app.post('/api/users', (req, res) => {
res.json({ message: 'User berhasil ditambahkan' });
});
32.3 PUT
app.put('/api/users/:id', (req, res) => {
res.json({ message: 'User diperbarui' });
});
32.4 DELETE
app.delete('/api/users/:id', (req, res) => {
res.json({ message: 'User dihapus' });
});
33. Integrasi Express.js dengan MySQL
Express.js sering dikombinasikan dengan MySQL untuk backend aplikasi web.
npm install mysql2
const mysql = require('mysql2');
const db = mysql.createConnection({
host: 'localhost',
user: 'root',
password: '',
database: 'db_app'
});
db.connect();
34. Error Handling Express.js
app.use((err, req, res, next) => {
res.status(500).json({ error: err.message });
});
35. Best Practice Express.js
- Pisahkan route dan controller
- Gunakan middleware untuk validasi
- Gunakan environment variable
36. Hubungan Node.js dengan Frontend
Node.js sering digunakan untuk melayani frontend berbasis HTML, CSS, dan JavaScript.
37. Ringkasan Ke 3
Pada bagian ini, Anda telah mempelajari Express.js, routing, middleware, dan REST API dasar. Bagian berikutnya akan membahas asynchronous programming, security, dan deployment.
38. Asynchronous Programming pada Node.js
Node.js dirancang untuk menangani proses asynchronous agar aplikasi tetap responsif meskipun menangani banyak request.
38.1 Callback
fs.readFile('data.txt', (err, data) => {
if (err) throw err;
console.log(data.toString());
});
38.2 Promise
const fs = require('fs').promises;
fs.readFile('data.txt')
.then(data => console.log(data.toString()))
.catch(err => console.error(err));
38.3 Async / Await
async function bacaFile() {
try {
const data = await fs.readFile('data.txt');
console.log(data.toString());
} catch (err) {
console.error(err);
}
}
39. Environment Variable
Environment variable digunakan untuk menyimpan konfigurasi sensitif.
npm install dotenv
require('dotenv').config();
console.log(process.env.PORT);
40. Security Dasar Node.js
- Gunakan HTTPS
- Validasi input
- Hindari eval()
- Gunakan dependency terpercaya
40.1 Helmet
npm install helmet
const helmet = require('helmet');
app.use(helmet());
41. Authentication (Auth)
Authentication digunakan untuk memastikan identitas pengguna.
41.1 JSON Web Token (JWT)
npm install jsonwebtoken
const jwt = require('jsonwebtoken');
const token = jwt.sign(
{ userId: 1 },
process.env.JWT_SECRET,
{ expiresIn: '1h' }
);
41.2 Middleware Auth
function auth(req, res, next) {
const token = req.headers.authorization;
if (!token) return res.status(401).send('Unauthorized');
try {
jwt.verify(token, process.env.JWT_SECRET);
next();
} catch {
res.status(403).send('Forbidden');
}
}
42. Upload File
npm install multer
const multer = require('multer');
const upload = multer({ dest: 'uploads/' });
app.post('/upload', upload.single('file'), (req, res) => {
res.send('File uploaded');
});
43. Logging & Monitoring
- Gunakan morgan untuk logging HTTP
- Gunakan PM2 untuk process management
npm install morgan pm2 -g
44. Deployment Node.js
Node.js dapat dideploy di berbagai platform seperti VPS dan cloud hosting.
44.1 Menjalankan dengan PM2
pm2 start index.js --name app-node
pm2 save
pm2 startup
45. Node.js Best Practice
- Pisahkan config dan logic
- Gunakan async/await
- Logging dan monitoring aktif
46. Kaitan Node.js dengan Teknologi Web Lain
47. Ringkasan Dokumentasi Node.js Ke 4
Pada bagian ini, Anda telah mempelajari asynchronous programming, security, authentication, dan deployment Node.js. Bagian terakhir akan membahas studi kasus, FAQ, dan schema SEO.
48. Study Case Node.js: REST API Sederhana dengan Express & MySQL
Studi kasus ini menggambarkan penerapan Node.js dalam membangun REST API sederhana untuk aplikasi manajemen user menggunakan Express.js dan MySQL.
48.1 Struktur Folder Project
project-api/
├── config/
│ └── db.js
├── routes/
│ └── users.js
├── controllers/
│ └── userController.js
├── index.js
└── package.json
48.2 Koneksi Database MySQL
// config/db.js
const mysql = require('mysql2');
const db = mysql.createConnection({
host: 'localhost',
user: 'root',
password: '',
database: 'db_node'
});
module.exports = db;
48.3 Controller User
// controllers/userController.js
const db = require('../config/db');
exports.getUsers = (req, res) => {
db.query('SELECT * FROM users', (err, results) => {
if (err) return res.status(500).json(err);
res.json(results);
});
};
48.4 Routing API
// routes/users.js
const express = require('express');
const router = express.Router();
const userController = require('../controllers/userController');
router.get('/', userController.getUsers);
module.exports = router;
48.5 Inisialisasi Server
// index.js
const express = require('express');
const app = express();
const userRoutes = require('./routes/users');
app.use(express.json());
app.use('/api/users', userRoutes);
app.listen(3000, () => {
console.log('API berjalan di http://localhost:3000');
});
49. FAQ (Pertanyaan yang Sering Diajukan)
49.1 Apa itu Node.js?
Node.js adalah runtime JavaScript berbasis V8 Engine yang digunakan untuk menjalankan JavaScript di sisi server.
49.2 Apakah Node.js cocok untuk aplikasi besar?
Ya. Node.js banyak digunakan untuk aplikasi skala besar karena arsitektur non-blocking dan dukungan ekosistem yang luas.
49.3 Apa perbedaan Node.js dan PHP?
Node.js menggunakan model asynchronous dan event-driven, sedangkan PHP secara default bersifat synchronous.
49.4 Apakah Node.js aman?
Node.js aman jika menerapkan praktik security seperti validasi input, HTTPS, JWT, dan dependency management yang baik.
49.5 Kapan sebaiknya menggunakan Node.js?
Node.js ideal untuk aplikasi real-time, REST API, dan microservices dengan traffic tinggi.
50. Penutup
Dokumentasi Node.js ini membahas konsep dasar hingga lanjutan, mulai dari arsitektur, core module, Express.js, REST API, security, deployment, hingga studi kasus nyata. Dengan pemahaman ini, Anda siap membangun backend web modern menggunakan Node.js secara profesional.
Bacaan lanjutan: