Node.js untuk Pemula
Indonesian (Bahasa Indonesia) translation by ⚡ Rova Rindrata (you can also view the original English article)
Pemrograman berbasis event bisa sangat luar biasa untuk pemula, yang bisa membuat Node.js sulit untuk dimulai. Tapi jangan biarkan hal itu menghalangi Anda; Pada artikel ini, saya akan mengajarkan beberapa dasar-dasar Node.js dan menjelaskan mengapa ia menjadi sangat populer.
Perkenalan
Untuk mulai menggunakan Node.js, Anda harus terlebih dahulu memahami perbedaan antara Node.js dan lingkungan skrip sisi-server tradisional (misalnya: PHP, Python, Ruby, dll.).
Pemrograman Asinkron
Node.js menggunakan arsitektur modul untuk mempermudah pembuatan aplikasi yang kompleks.
Kemungkinan bagus bahwa Anda terbiasa dengan pemrograman asinkron; itu, setelah semua, "A" di Ajax. Setiap fungsi di Node.js bersifat asinkron. Oleh karena itu, semua yang biasanya memblokir thread malah dieksekusi di latar belakang. Ini adalah hal terpenting untuk diingat tentang Node.js. Misalnya, jika Anda membaca file pada sistem file, Anda harus menentukan fungsi callback yang dijalankan ketika operasi baca selesai.
Anda yang Melakukan Segalanya!
Node.js hanyalah sebuah lingkungan - yang berarti Anda harus melakukan semuanya sendiri. Tidak ada server HTTP default, atau server apa pun dalam hal ini. Ini bisa sangat luar biasa bagi pengguna baru, tetapi hasilnya adalah aplikasi web berkinerja tinggi. Satu skrip menangani semua komunikasi dengan klien. Hal ini sangat mengurangi jumlah sumber daya yang digunakan oleh aplikasi. Sebagai contoh, berikut adalah kode untuk aplikasi Node.js sederhana:
1 |
var i, a, b, c, max; |
2 |
|
3 |
max = 1000000000; |
4 |
|
5 |
var d = Date.now(); |
6 |
|
7 |
for (i = 0; i < max; i++) {
|
8 |
a = 1234 + 5678 + i; |
9 |
b = 1234 * 5678 + i; |
10 |
c = 1234 / 2 + i; |
11 |
} |
12 |
|
13 |
console.log(Date.now() - d); |
Dan di sini adalah yang setara ditulis dalam PHP:
1 |
$a = null; |
2 |
$b = null; |
3 |
$c = null; |
4 |
$i = null; |
5 |
$max = 1000000000; |
6 |
|
7 |
$start = microtime(true); |
8 |
|
9 |
for ($i = 0; $i < $max; $i++) { |
10 |
$a = 1234 + 5678 + $i; |
11 |
$b = 1234 * 5678 + $i; |
12 |
$c = 1234 / 2 + $i; |
13 |
}
|
14 |
|
15 |
var_dump(microtime(true) - $start); |
Sekarang mari kita lihat angka benchmarknya. Tabel berikut mencantumkan waktu respon, dalam milidetik, untuk dua aplikasi sederhana ini:
| Jumlah iterasi | Node.js | PHP |
| 100 | 2.00 | 0.14 |
| 10'000 | 3.00 | 10.53 |
| 1'000'000 | 15.00 | 1119.24 |
| 10'000'000 | 143.00 | 10621.46 |
| 1'000'000'000 | 11118.00 | 1036272.19 |
Saya menjalankan dua aplikasi dari baris perintah sehingga server tidak akan menunda eksekusi aplikasi. Saya menjalankan setiap tes sepuluh kali dan merata-rata hasilnya. PHP terutama lebih cepat dengan jumlah iterasi yang lebih sedikit, namun keuntungan itu cepat menghilang seiring bertambahnya jumlah iterasi. Ketika semua dikatakan dan dilakukan, PHP 93% lebih lambat dari Node.js!
Node.js cepat, tapi Anda perlu mempelajari beberapa hal agar bisa menggunakannya dengan benar.
Modul-modul
Node.js menggunakan arsitektur modul untuk mempermudah pembuatan aplikasi yang kompleks. Modul mirip dengan pustaka di C, atau unit dalam Pascal. Setiap modul berisi satu set fungsi yang terkait dengan "subjek" dari modul. Misalnya, modul http berisi fungsi khusus untuk HTTP. Node.js menyediakan beberapa modul inti di luar kotak untuk membantu Anda mengakses file pada sistem file, membuat server HTTP dan TCP/UDP, dan melakukan fungsi berguna lainnya.
Memasukkan modul itu mudah; cukup panggil fungsi require(), seperti ini:
1 |
var http = require('http');
|
Node.js hanyalah sebuah lingkungan; Anda yang harus melakukan semuanya sendiri.
Fungsi require() mengembalikan referensi ke modul yang ditentukan. Dalam kasus kode ini, referensi ke modul http disimpan dalam variabel http.
Dalam kode di atas, kami memberikan nama modul ke fungsi require(). Ini menyebabkan Node mencari folder node_modules di direktori aplikasi kita, dan mencari modul http di folder itu. Jika Node tidak menemukan folder node_modules (atau modul http di dalamnya), maka Node akan melihat melalui cache modul global. Anda juga dapat menentukan file yang sebenarnya dengan melewatkan path relatif atau absolut, seperti:
1 |
var myModule = require('./myModule.js');
|
Modul adalah potongan kode yang dienkapsulasi. Kode dalam modul sebagian besar bersifat private - yang berarti bahwa fungsi dan variabel yang ditentukan di dalamnya hanya dapat diakses dari bagian dalam modul. Anda dapat, bagaimanapun, mengekspos fungsi dan/atau variabel yang akan digunakan di luar modul. Untuk melakukannya, gunakan objek exports dan isi properti dan metodenya dengan potongan kode yang ingin Anda paparkan. Perhatikan modul berikut ini sebagai contoh:
1 |
var PI = Math.PI; |
2 |
|
3 |
exports.area = function (r) {
|
4 |
return PI * r * r; |
5 |
}; |
6 |
|
7 |
exports.circumference = function (r) {
|
8 |
return 2 * PI * r; |
9 |
}; |
Kode ini menciptakan variabel PI yang hanya dapat diakses oleh kode yang terdapat dalam modul; tidak dapat diakses di luar modul. Selanjutnya, dua fungsi diciptakan pada objek exports. Fungsi-fungsi ini dapat diakses di luar modul karena mereka didefinisikan pada objek exports. Akibatnya, PI benar-benar terlindungi dari gangguan luar. Oleh karena itu, Anda dapat yakin bahwa area() dan circumference() akan selalu berperilaku sebagaimana mestinya (selama sebuah nilai diberikan untuk parameter r).
Lingkup Global
Node adalah lingkungan JavaScript yang berjalan di mesin JavaScript V8 dari Google. Dengan demikian, kita harus mengikuti praktik terbaik yang kita gunakan untuk pengembangan sisi-klien. Misalnya, kita harus menghindari menempatkan sesuatu ke dalam lingkup global. Itu, bagaimanapun, tidak selalu memungkinkan. Lingkup global di Node adalah GLOBAL (berlawanan dengan window di browser), dan Anda dapat dengan mudah membuat variabel global dari fungsi dengan menghilangkan kata kunci var, seperti ini:
1 |
globalVariable = 1; |
2 |
globalFunction = function () { ... };
|
Sekali lagi, globals harus dihindari sebisa mungkin. Jadi hati-hati dan ingatlah untuk menggunakan var saat mendeklarasikan sebuah variabel.
Instalasi
Tentu, kita perlu menginstal Node sebelum kita bisa menulis dan menjalankan sebuah aplikasi. Instalasinya sederhana, jika Anda menggunakan Windows atau OS X; situs nodejs.org menawarkan installer untuk sistem operasi tersebut. Untuk Linux, gunakan manajer paket. Buka terminal dan ketik:
1 |
sudo apt-get update |
2 |
sudo apt-get install node |
atau:
1 |
sudo aptitude update |
2 |
sudo aptitude install node |
Node.js berada di sid repositories; Anda mungkin perlu menambahkannya ke daftar sumber Anda:
1 |
sudo echo deb http://ftp.us.debian.org/debian/ sid main > /etc/apt/sources.list.d/sid.list |
Namun perlu diingat bahwa menginstal paket sid pada sistem yang lebih tua dapat merusak sistem Anda. Hati-hati, dan hapus /etc/apt/sources.list.d/sid.list setelah Anda selesai menginstal Node.
Memasang Modul Baru
Node.js memiliki manajer paket, yang disebut Node Package Manager (NPM). Ini otomatis diinstal dengan Node.js, dan Anda menggunakan NPM untuk menginstal modul baru. Untuk menginstal modul, buka terminal/command line Anda, navigasikan ke folder yang diinginkan, dan jalankan perintah berikut:
1 |
npm install module_name |
Tidak masalah OS apa yang Anda punya; perintah di atas akan menginstal modul yang Anda tentukan di tempat module_name.
Aplikasi Hello World
Tentu, skrip Node.js pertama kita akan mencetak teks 'Hello World!' ke konsol. Buat file yang bernama hello.js, dan ketik kode berikut:
1 |
console.log('Hello World!');
|
Sekarang mari kita jalankan skripnya. Buka terminal/command line, arahkan ke folder yang berisi hello.js, dan jalankan perintah berikut:
1 |
node hello.js |
Anda harus melihat 'Hello World!' ditampilkan di konsol.
Server HTTP
Mari beralih ke aplikasi yang lebih canggih; itu tidak serumit yang mungkin Anda pikirkan. Mari kita mulai dengan kode berikut. Baca komentarnya dan kemudian penjelasannya di bawah ini:
1 |
// Include http module. |
2 |
var http = require("http");
|
3 |
|
4 |
// Create the server. Function passed as parameter is called on every request made. |
5 |
// request variable holds all request parameters |
6 |
// response variable allows you to do anything with response sent to the client. |
7 |
http.createServer(function (request, response) {
|
8 |
// Attach listener on end event. |
9 |
// This event is called when client sent all data and is waiting for response. |
10 |
request.on("end", function () {
|
11 |
// Write headers to the response. |
12 |
// 200 is HTTP status code (this one means success) |
13 |
// Second parameter holds header fields in object |
14 |
// We are sending plain text, so Content-Type should be text/plain |
15 |
response.writeHead(200, {
|
16 |
'Content-Type': 'text/plain' |
17 |
}); |
18 |
// Send data and end response. |
19 |
response.end('Hello HTTP!');
|
20 |
}); |
21 |
// Listen on the 8080 port. |
22 |
}).listen(8080); |
Kode ini sangat sederhana. Anda dapat mengirim lebih banyak data ke klien dengan menggunakan metode response.write() , namun Anda harus memanggilnya sebelum memanggil response.end(). Simpan kode ini sebagai http.js dan ketik ini ke konsol Anda:
1 |
node http.js |
Buka browser Anda dan navigasikan ke http://localhost:8080. Anda harus melihat teks "Hello HTTP!" di halaman.
Menangani Parameter URL
Seperti yang saya sebutkan sebelumnya, kita harus melakukan semuanya sendiri di Node, termasuk menguraikan argumen permintaan. Ini, bagaimanapun, cukup sederhana. Lihatlah kode berikut ini:
1 |
// Include http module, |
2 |
var http = require("http"),
|
3 |
// And url module, which is very helpful in parsing request parameters. |
4 |
url = require("url");
|
5 |
|
6 |
// Create the server. |
7 |
http.createServer(function (request, response) {
|
8 |
// Attach listener on end event. |
9 |
request.on('end', function () {
|
10 |
// Parse the request for arguments and store them in _get variable. |
11 |
// This function parses the url from request and returns object representation. |
12 |
var _get = url.parse(request.url, true).query; |
13 |
// Write headers to the response. |
14 |
response.writeHead(200, {
|
15 |
'Content-Type': 'text/plain' |
16 |
}); |
17 |
// Send data and end response. |
18 |
response.end('Here is your data: ' + _get['data']);
|
19 |
}); |
20 |
// Listen on the 8080 port. |
21 |
}).listen(8080); |
Kode ini menggunakan metode parse() dari modul url, modul inti Node.js, untuk mengubah URL permintaan ke sebuah objek. Objek yang dikembalikan memiliki properti query, yang mengambil parameter URL. Simpan file ini sebagai get.js dan jalankan dengan perintah berikut:
1 |
node get.js |
Lalu, navigasikan ke http://localhost:8080/?data=put_some_text_here di browser Anda. Tentu, mengubah nilai parameter data tidak akan merusak skrip.
Membaca dan Menulis File
Untuk mengatur file di Node, kita menggunakan modul fs (modul inti). Kita membaca dan menulis file menggunakan metode fs.readFile() dan fs.writeFile(). Saya akan menjelaskan argumen-argumennya setelah kode berikut:
1 |
// Include http module, |
2 |
var http = require("http"),
|
3 |
// And mysql module you've just installed. |
4 |
fs = require("fs");
|
5 |
|
6 |
// Create the http server. |
7 |
http.createServer(function (request, response) {
|
8 |
// Attach listener on end event. |
9 |
request.on("end", function () {
|
10 |
// Read the file. |
11 |
fs.readFile("test.txt", 'utf-8', function (error, data) {
|
12 |
// Write headers. |
13 |
response.writeHead(200, {
|
14 |
'Content-Type': 'text/plain' |
15 |
}); |
16 |
// Increment the number obtained from file. |
17 |
data = parseInt(data) + 1; |
18 |
// Write incremented number to file. |
19 |
fs.writeFile('test.txt', data);
|
20 |
// End response with some nice message. |
21 |
response.end('This page was refreshed ' + data + ' times!');
|
22 |
}); |
23 |
}); |
24 |
// Listen on the 8080 port. |
25 |
}).listen(8080); |
Node.js memiliki manajer paket, yang disebut Node Package Manager (NPM). Ini otomatis dipasang dengan Node.js
Simpan ini sebagai files.js. Sebelum menjalankan skrip ini, buatlah sebuah file bernama test.txt di direktori yang sama dengan files.js.
Kode ini mendemokan metode fs.readFile() dan fs.writeFile(). Setiap kali server menerima permintaan, skrip tersebut membaca sebuah nomor dari file, menambahkan nomornya, dan menulis nomor baru ke file tersebut. Metode fs.readFile() menerima tiga argumen: nama file yang akan dibaca, pengkodean yang diharapkan, dan fungsi callback.
Menulis ke file, setidaknya dalam kasus ini, jauh lebih sederhana. Kita tidak perlu menunggu hasil apapun, meski Anda akan mengecek kesalahan dalam aplikasi nyata. Metode fs.writeFile() menerima nama file dan data sebagai argumen. Ini juga menerima argumen ketiga dan keempat (keduanya opsional) untuk menentukan fungsi pengkodean dan callback.
Sekarang, mari jalankan skrip ini dengan perintah berikut:
1 |
node files.js |
Buka di browser (http://localhost:8080) dan segarkan beberapa kali. Sekarang, Anda mungkin berpikir bahwa ada kesalahan dalam kode karena tampaknya meningkat dua kali. Ini bukan sebuah kesalahan. Setiap kali Anda meminta URL ini, dua permintaan dikirim ke server. Permintaan pertama dibuat secara otomatis oleh browser, yang meminta favicon.ico, dan tentu saja, permintaan kedua adalah untuk URL (http://localhost:8080).
Meski perilaku ini secara teknis bukan merupakan kesalahan, itu adalah perilaku yang tidak kita inginkan. Kita dapat memperbaikinya dengan mudah dengan memeriksa URL permintaan. Berikut adalah kode yang direvisi:
1 |
// Include http module, |
2 |
var http = require("http"),
|
3 |
// And mysql module you've just installed. |
4 |
fs = require("fs");
|
5 |
|
6 |
// Create the http server. |
7 |
http.createServer(function (request, response) {
|
8 |
// Attach listener on end event. |
9 |
request.on('end', function () {
|
10 |
// Check if user requests / |
11 |
if (request.url == '/') {
|
12 |
// Read the file. |
13 |
fs.readFile('test.txt', 'utf-8', function (error, data) {
|
14 |
// Write headers. |
15 |
response.writeHead(200, {
|
16 |
'Content-Type': 'text/plain' |
17 |
}); |
18 |
// Increment the number obtained from file. |
19 |
data = parseInt(data) + 1; |
20 |
// Write incremented number to file. |
21 |
fs.writeFile('test.txt', data);
|
22 |
// End response with some nice message. |
23 |
response.end('This page was refreshed ' + data + ' times!');
|
24 |
}); |
25 |
} else {
|
26 |
// Indicate that requested file was not found. |
27 |
response.writeHead(404); |
28 |
// And end request without sending any data. |
29 |
response.end(); |
30 |
} |
31 |
}); |
32 |
// Listen on the 8080 port. |
33 |
}).listen(8080); |
Ujilah sekarang; itu harus bekerja seperti yang diharapkan.
Mengakses Database MySQL
Sebagian besar teknologi sisi-server tradisional memiliki cara bawaan untuk menghubungkan dan melakukan kueri database. Dengan Node.js, Anda harus menginstal sebuah perpustakaan. Untuk tutorial ini, saya sudah memilih node-mysql yang stabil dan mudah digunakan. Nama lengkap dari modul ini adalah mysql@2.0.0-alpha2 (semuanya setelah @ adalah nomor versi). Buka konsol Anda, arahkan ke direktori tempat Anda menyimpan skrip Anda, dan jalankan perintah berikut:
1 |
npm install mysql@2.0.0-alpha2 |
Ini mengunduh dan menginstal modul, dan juga membuat folder node_modules di direktori saat ini. Sekarang mari kita lihat bagaimana kita bisa menggunakan ini dalam kode kita; lihat contoh berikut ini:
1 |
// Include http module, |
2 |
var http = require('http'),
|
3 |
// And mysql module you've just installed. |
4 |
mysql = require("mysql");
|
5 |
|
6 |
// Create the connection. |
7 |
// Data is default to new mysql installation and should be changed according to your configuration. |
8 |
var connection = mysql.createConnection({
|
9 |
user: "root", |
10 |
password: "", |
11 |
database: "db_name" |
12 |
}); |
13 |
|
14 |
// Create the http server. |
15 |
http.createServer(function (request, response) {
|
16 |
// Attach listener on end event. |
17 |
request.on('end', function () {
|
18 |
// Query the database. |
19 |
connection.query('SELECT * FROM your_table;', function (error, rows, fields) {
|
20 |
response.writeHead(200, {
|
21 |
'Content-Type': 'x-application/json' |
22 |
}); |
23 |
// Send data as JSON string. |
24 |
// Rows variable holds the result of the query. |
25 |
response.end(JSON.stringify(rows)); |
26 |
}); |
27 |
}); |
28 |
// Listen on the 8080 port. |
29 |
}).listen(8080); |
Melakukan kueri database dengan perpustakaan ini mudah; cukup masukkan string kueri dan fungsi callback. Dalam aplikasi nyata, Anda harus memeriksa apakah ada kesalahan (parameter error tidak akan menjadi undefined jika terjadi kesalahan) dan mengirim kode respons bergantung pada keberhasilan atau kegagalan kueri. Perhatikan juga bahwa kita telah menetapkan Content-Type menjadi x-application/json, yang merupakan tipe MIME yang valid untuk JSON. Parameter rows berisi hasil kueri, dan kita cukup mengonversi data dalam rows ke struktur JSON menggunakan metode JSON.stringify() .
Simpan file ini sebagai mysql.js, dan jalankan (jika Anda menginstal MySQL, yaitu):
1 |
node mysql.js |
Arahkan ke http://localhost:8080 di browser Anda, dan Anda harus diminta mengunduh file berformat JSON.
Kesimpulan
Setiap fungsi di Node.js bersifat asinkron.
Node.js membutuhkan kerja ekstra, tetapi hasil dari aplikasi yang cepat dan kuat sangat layak. Jika Anda tidak ingin melakukan semuanya pada tingkat terendah, Anda selalu dapat memilih beberapa kerangka kerja, seperti >Express, untuk mempermudah pengembangan aplikasi.
Node.js adalah teknologi yang menjanjikan dan pilihan yang sangat baik untuk aplikasi dengan beban tinggi. Ini telah dibuktikan oleh banyak perusahaan, seperti Microsoft, eBay, dan Yahoo. Jika Anda tidak yakin tentang hosting situs web/aplikasi Anda, Anda selalu dapat menggunakan solusi VPS murah atau berbagai layanan berbasis cloud, seperti Microsoft Azure dan Amazon EC2. Semua layanan ini menyediakan lingkungan terukur dengan harga yang wajar.
Jangan lupa untuk berkomentar jika ada pertanyaan!



