Indonesian (Bahasa Indonesia) translation by Muhammad Gufron (you can also view the original English article)
Node.js semua buzz pada saat ini, dan membuat menciptakan kinerja tinggi, aplikasi real-time web mudah. Hal ini memungkinkan JavaScript untuk digunakan ujung ke ujung, baik di server maupun di klien. Tutorial ini akan memandu Anda melalui instalasi Node dan program pertama Anda "Hello World", untuk membangun sebuah server Twitter streaming yang terukur.
Apakah Node.js?
JavaScript memiliki secara tradisional hanya berjalan di web browser, tetapi baru-baru ini telah ada minat yang besar membawanya ke sisi server juga, berkat CommonJS proyek. Lingkungan server-side JavaScript lainnya termasuk Jaxer dan Narwhal. Namun, Node.js sedikit berbeda dari solusi ini, karena itu berdasarkan aktivitas daripada berbasis thread. Server web seperti Apache yang digunakan untuk melayani PHP dan skrip CGI lainnya berbasis thread karena mereka menelurkan thread sistem untuk setiap permintaan yang masuk. Meskipun ini bagus untuk banyak aplikasi, tetapi model berbasis utas tidak cukup baik dengan banyak sambungan berumur panjang seperti yang Anda perlukan untuk melayani aplikasi real-time seperti Friendfeed atau Google Wave.
"Setiap operasi I/O di Node.js adalah asynchronous..."
Node.js, menggunakan event loop bukan threads, dan mampu berskala jutaan sambungan. Ini mengambil keuntungan dari fakta bahwa server menghabiskan sebagian besar waktu mereka untuk menunggu operasi I/O, seperti membaca file dari hard drive, mengakses layanan web eksternal atau menunggu file selesai diunggah, karena operasi ini jauh lebih lambat. dari pada operasi memori. Setiap operasi I/O di Node.js asynchronous, berarti bahwa server dapat melanjutkan untuk memproses permintaan masuk ketika operasi I/O berlangsung. JavaScript sangat cocok untuk pemrograman berbasis event karena memiliki fungsi anonim dan penutupan yang membuat pendefinisian inline callback menjadi mudah, dan pengembang JavaScript sudah tahu cara memprogram dengan cara ini. Model berbasis event ini membuat Node.js sangat cepat, dan membuat penskalaan aplikasi real-time sangat mudah.
Langkah 1 Instalasi
Node.js berjalan pada Unix berbasis sistem, Mac OS X, Linux dan FreeBSD. Sayangnya, Windows tidak lagi didukung, jadi jika Anda pengguna Windows, Anda dapat menginstalnya di Ubuntu Linux menggunakan Virtualbox. Untuk melakukannya, ikuti tutorial ini. Anda akan perlu menggunakan terminal untuk menginstal dan menjalankan Node.js.
- Download rilis terbaru dari Node.js dari nodejs.org (versi terbaru pada saat tulisan ini adalah 0.1.31) dan extract.
- Buka terminal dan jalankan perintah berikut.
cd /path/to/nodejs make sudo make install
Banyak pesan akan dikeluarkan ke terminal saat Node.js dikompilasi dan diinstal.
Langkah 2 Hello World!
Setiap teknologi baru di mulai dengan tutorial "Hello World!", jadi kita akan menciptakan HTTP server sederhana yang menyajikan pesan itu. Pertama, Anda harus memahami sistem modul Node.js. Di Node, fungsi diringkas dalam modul yang harus dimuat agar dapat digunakan. Ada banyak modul yang terdaftar dalam dokumentasi Node.js. Anda memuat modul ini dengan menggunakan fungsi require seperti:
var sys = require("sys"); Ini memuat modul sys, yang berisi fungsi untuk menangani tugas tingkat sistem seperti mencetak output ke terminal. Untuk menggunakan fungsi dalam modul, Anda memanggilnya pada variabel tempat Anda menyimpan modul, dalam kasus kami sys.
sys.puts("Hello World!"); Jalankan dua baris yang sederhana seperti menjalankan perintah node dengan nama file dari file javascript sebagai argumen.
node test.js
Ini akan menampilkan "Hello World!" ke baris perintah ketika dijalankan.
Untuk membuat HTTP server, Anda harus require modul http.
var sys = require("sys"),
http = require("http");
http.createServer(function(request, response) {
response.sendHeader(200, {"Content-Type": "text/html"});
response.write("Hello World!");
response.close();
}).listen(8080);
sys.puts("Server running at http://localhost:8080/"); Script ini mengimpor modul sys dan http, dan membuat HTTP server. Fungsi anonim yang dilewatkan ke dalam http.createServer akan dipanggil setiap kali permintaan masuk ke server. Setelah server dibuat, diberitahu untuk menggunakan port 8080. Ketika permintaan ke server masuk, kami pertama kali mengirimkan header HTTP dengan konten jenis dan status Kode 200 (berhasil). Kemudian kami mengirim "Hello World!" dan menutup sambungan. Anda mungkin melihat bahwa kita harus secara eksplisit menutup sambungan. Ini akan membuatnya sangat mudah untuk aliran data ke klien tanpa menutup sambungan. Jika Anda menjalankan script ini dan membuka http://localhost:8080/ di browser Anda, Anda akan melihat "Hello World!"
Langkah 3 Server File Statis Sederhana
OK, jadi kami telah membangun sebuah server HTTP, tapi itu tidak mengirimkan apa-apa kecuali "Hello World", tidak peduli apa URL Anda. Setiap server HTTP harus dapat mengirim file statis seperti file HTML, gambar dan file lainnya. Kode berikut tidak hanya itu:
var sys = require("sys"),
http = require("http"),
url = require("url"),
path = require("path"),
fs = require("fs");
http.createServer(function(request, response) {
var uri = url.parse(request.url).pathname;
var filename = path.join(process.cwd(), uri);
path.exists(filename, function(exists) {
if(!exists) {
response.sendHeader(404, {"Content-Type": "text/plain"});
response.write("404 Not Found\n");
response.close();
return;
}
fs.readFile(filename, "binary", function(err, file) {
if(err) {
response.sendHeader(500, {"Content-Type": "text/plain"});
response.write(err + "\n");
response.close();
return;
}
response.sendHeader(200);
response.write(file, "binary");
response.close();
});
});
}).listen(8080);
sys.puts("Server running at http://localhost:8080/"); Kita mulai dengan mengharuskan semua modul yang kita perlu dalam kode kita. Ini termasuk modul sys, http, url, path, dan fs atau filesystem. Selanjutnya kita buat HTTP server seperti yang kita lakukan sebelumnya. Saat ini, kami akan menggunakan modul url untuk mem-parsing URL masuk masuk dan menemukan nama path file yang diakses. Kita menemukan nama sebenarnya pada server hard drive dengan menggunakan path.join, yang bergabung process.cwd(), atau direktori kerja saat ini, dengan path ke file yang diminta. Selanjutnya, kami memeriksa jika ada file, yang operasi asynchronous dan dengan demikian membutuhkan callback. Jika file tidak ada, 404 Not Found pesan dikirim ke pengguna dan fungsi kembali. Jika tidak, kita membaca file menggunakan modul fs menggunakan "biner" pengkodean, dan mengirim file ke pengguna. Jika ada kesalahan membaca file, kami menyajikan pesan error kepada pengguna, dan menutup koneksi. Karena semua ini asynchronous, server sudah mampu melayani permintaan lainnya saat membaca file dari disk tidak peduli seberapa besar itu.
Jika Anda menjalankan contoh ini, dan navigasikan ke http://localhost:8080/path/to/file, file tersebut akan ditampilkan dalam browser Anda.
Langkah 4 Real Time Tweet Streamer
Bangunan pada server file statis kami, kami akan membangun sebuah server di Node.js yang tweets aliran kepada klien yang ditayangkan melalui server file statis kami. Untuk memulai, kita akan membutuhkan satu tambahan modul dalam contoh ini: modul events. Node memiliki konsep yang disebut EventEmitter, yang digunakan untuk seluruh menangani acara pendengar untuk tugas-tugas asynchronous. Seperti dalam jQuery atau lain kerangka JavaScript sisi klien mana Anda bind event listeners untuk hal-hal seperti klik mouse, dan permintaan AJAX, Node memungkinkan Anda untuk bind event listeners untuk banyak hal, beberapa di antaranya kita telah menggunakannya. Ini termasuk setiap operasi I/O, membaca file menulis file, memeriksa apakah file ada, menunggu permintaan HTTP, dll. EventEmitter abstrak logika binding, unbinding, dan mentriger seperti event listener. Kita akan menggunakan EventEmitter untuk memberitahu listener ketika tweets baru dimuat. Beberapa baris pertama dari tweet streamer kami impor semua modul yang diperlukan, dan definisikan fungsi untuk penanganan file statis, yang diambil dari contoh kami sebelumnya.
var sys = require("sys"),
http = require("http"),
url = require("url"),
path = require("path"),
fs = require("fs"),
events = require("events");
function load_static_file(uri, response) {
var filename = path.join(process.cwd(), uri);
path.exists(filename, function(exists) {
if(!exists) {
response.sendHeader(404, {"Content-Type": "text/plain"});
response.write("404 Not Found\n");
response.close();
return;
}
fs.readFile(filename, "binary", function(err, file) {
if(err) {
response.sendHeader(500, {"Content-Type": "text/plain"});
response.write(err + "\n");
response.close();
return;
}
response.sendHeader(200);
response.write(file, "binary");
response.close();
});
});
} Kami telah menggunakan modul http untuk membuat server sebelum, tetapi juga memungkinkan untuk membuat klien HTTP yang menggunakan modul. Kita akan membuat sebuah HTTP client untuk memuat tweets dari Twitter timeline publik, yang dilakukan oleh fungsi get_tweets.
var twitter_client = http.createClient(80, "api.twitter.com");
var tweet_emitter = new events.EventEmitter();
function get_tweets() {
var request = twitter_client.request("GET", "/1/statuses/public_timeline.json", {"host": "api.twitter.com"});
request.addListener("response", function(response) {
var body = "";
response.addListener("data", function(data) {
body += data;
});
response.addListener("end", function() {
var tweets = JSON.parse(body);
if(tweets.length > 0) {
tweet_emitter.emit("tweets", tweets);
}
});
});
request.close();
}
setInterval(get_tweets, 5000); Pertama, kami menciptakan sebuah HTTP klien pada port 80 di api.twitter.com, dan menciptakan EventEmitter baru. Fungsi get_tweets membuat permintaan HTTP "GET" untuk Twitter timeline publik, dan menambahkan event listener yang akan menjadi trigger ketika server Twitter merespon. Karena Node.js asynchronous, data dalam body respon datang dalam potongan, yang pilih oleh respon "data" listener. Listener ini hanya menambahkan potongan body variabel. Setelah semua potongan telah datang, listener "end" ditrigger, dan kita parse data JSON yang masuk. Jika lebih dari satu tweet hasil kembalian, kita emit event "tweets" pada tweet_emitter kami, dan melewati dalam array baru tweets. Ini akan mentrigger semua event listener yang melister event "tweets", dan mengirim tweets baru untuk setiap klien. Kita mengambil tweet baru setiap lima detik, dengan menggunakan setInterval.
Akhirnya, kita perlu membuat server HTTP untuk menangani permintaan.
http.createServer(function(request, response) {
var uri = url.parse(request.url).pathname;
if(uri === "/stream") {
var listener = tweet_emitter.addListener("tweets", function(tweets) {
response.sendHeader(200, { "Content-Type" : "text/plain" });
response.write(JSON.stringify(tweets));
response.close();
clearTimeout(timeout);
});
var timeout = setTimeout(function() {
response.sendHeader(200, { "Content-Type" : "text/plain" });
response.write(JSON.stringify([]));
response.close();
tweet_emitter.removeListener(listener);
}, 10000);
}
else {
load_static_file(uri, response);
}
}).listen(8080);
sys.puts("Server running at http://localhost:8080/"); Seperti yang kita lakukan dengan server file statis kami, kami membuat server HTTP yang mengunakan port 8080. Kami mem-parsing URL yang diminta, dan jika URL yang sama dengan "/streaming", kami akan menangani hal itu, sebaliknya kita melewati permintaan ke server file statis kami. Streaming terdiri dari membuat listener untuk melisten tweets baru pada tweet_emitter kami, yang akan dipicu oleh fungsi get_tweets kita. Kita juga membuat sebuah timer untuk membunuh tht permintaan lebih dari 10 detik dengan mengirimkan array kosong. Ketika tweets baru masuk, kami mengirim tweets sebagai JSON data, dan timer yang jelas. Anda akan melihat bagaimana ini bekerja lebih baik setelah melihat kode sisi klien, yang berada di bawah. Simpan sebagai test.html di direktori yang sama sisi server JavaScript.
<!DOCTYPE html>
<html>
<head>
<title>Tweet Streamer</title>
<script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.4.2/jquery.min.js"></script>
</head>
<body>
<ul id="tweets"></ul>
<script type="text/javascript">
var tweet_list = $("#tweets");
function load_tweets() {
$.getJSON("/stream", function(tweets) {
$.each(tweets, function() {
$("<li>").html(this.text).prependTo(tweet_list);
});
load_tweets();
});
}
setTimeout(load_tweets, 1000);
</script>
</body>
</html> Di sini, kami memiliki halaman HTML sederhana yang megimpor library jQuery dan mendefinisikan daftar unordered untuk menempatkan tweets di dalamnya. Sisi JavaScript client kami men-cache daftar tweet, dan menjalankan fungsi load_tweets setelah satu detik. Ini memberikan browser cukup waktu untuk menyelesaikan loading halaman sebelum kita mulai permintaan AJAX ke server. Fungsi load_tweets sangat sederhana: menggunakan fungsi jQuery getJSON untuk memuat /stream. Ketika respon yang datang, kita loop melalui semua tweets dan menambahkan mereka ke daftar tweet. Kemudian, kita memanggil load_tweets lagi. Hal ini efektif menciptakan loop itu meload tweets baru, yang keluar setelah sepuluh detik karena batas waktu di server. Setiap kali ada tweets baru, mereka dipush untuk klien yang dipertahankan terus-menerus koneksi ke server. Teknik ini disebut long polling
Jika Anda menjalankan server menggunakan node dan pergi ke http://localhost:8080/test.html, Anda akan melihat timeline publik Twitter streaming ke browser Anda.
Langkah berikutnya
Node.js adalah teknologis yang angat menarik membuatnya mudah untuk menciptakan kinerja tinggi aplikasi real time. Saya berharap Anda dapat melihat manfaatnya, dan dapat menggunakannya dalam beberapa aplikasi Anda sendiri. Karena sistem modul besar Node, itu adalah mudah digunakan prewritten kode dalam aplikasi Anda, dan ada banyak modul pihak ketiga tersedia untuk hampir semua - termasuk lapisan koneksi database template engine, mail client, dan bahkan seluruh kerangka kerja yang menghubungkan semua hal ini bersama-sama. Anda dapat melihat daftar lengkap modul di Node.js wiki, dan tutorial Node lainnya dapat ditemukan pada How To Node. Saya juga merekomendasikan bahwa Anda menonton video dari JSConf, di mana Ryan Dahl, pencipta Node, menggambarkan filosofi desain di balik Node. Yang tersedia.
Saya harap Anda telah menikmati tutorial ini. Jika Anda memiliki komentar, Anda dapat meninggalkan satu di sini atau mengirim saya pesan di Twitter. Selamat coding!
