Node.js adalah runtime JavaScript open-source yang dibangun di atas mesin v8 chrome yang memungkinkan Anda menjalankan kode JavaScript di luar browser.
Model peristiwa, ekosistem, dan kecepatannya telah menjadikan Node.js salah satu runtime yang paling dicari dan digunakan untuk aplikasi sisi server.
Sebagian besar server API Node.js menggunakan Express atau kerangka kerja lain. Namun, Anda juga dapat membuat API Node.js sederhana tanpa kerangka kerja hanya dalam beberapa langkah.
Langkah 1: Menyiapkan Lingkungan Pengembangan Anda
Buat direktori proyek dan CD ke dalamnya dengan menjalankan:
mkdir nodejs-api
CD nodejs-api
Selanjutnya, inisialisasi npm di proyek Anda dengan menjalankan:
npm init -y
CRUD API ini akan menampilkan penggunaan MongoDB, database NoSQL, dan ODM populernya, luwak.
Jalankan perintah berikut untuk menginstal luwak:
npm Install luwak
Selanjutnya, buat server.js file di direktori root proyek Anda dan tambahkan blok kode di bawah ini untuk membuat server:
konstan http = memerlukan("http");
konstan server = http.createServer((req, res) => {});
server.listen (3000, () => {
menghibur.catatan(`Server sedang berjalan`);
});
Blok kode ini mengimpor modul http, modul inti Node.js. Modul http memungkinkan Node.js untuk mentransfer data melalui HTTP. Modul ini berisi metode yang diperlukan untuk membuat server.
Selanjutnya, ia memanggil modul http buat Server metode yang membuat dan mengembalikan instance server. Itu buat Server metode mengambil fungsi panggilan balik dengan objek permintaan dan respons sebagai parameter.
Selanjutnya, kode memanggil mendengarkan metode pada instance server yang dikembalikan. Ini memungkinkan server untuk mulai mendengarkan lalu lintas pada port yang diberikan. Itu mendengarkan metode menjalankan panggilan balik—argumen kedua—ketika berhasil.
Terakhir, buat dua direktori bernama rute dan model di direktori root proyek Anda. Itu rute folder akan berisi logika perutean untuk API Anda, sementara model akan berisi segala sesuatu yang berhubungan dengan database.
Langkah 2: Menghubungkan Aplikasi Anda ke Database
Di server.js, impor luwak:
konstan luwak = memerlukan("luwak");
Panggil Menghubung metode aktif luwak dan berikan URI MongoDB Anda sebagai argumen:
luwak.koneksi("MongoDB_URI")
Langkah 3: Membuat Model API
Buat CRUD API untuk aplikasi blog sederhana. di kamu model folder, buat blogModel.js file dan tambahkan kode berikut ke file Anda:
konstan luwak = memerlukan("luwak");
konstan blogSchema = luwak. Skema({
judul: {
Tipe: Rangkaian,
diperlukan: [benar, "Blog harus punya judul"],
},
tubuh: {
Tipe: Rangkaian,
diperlukan: [benar, "Blog harus memiliki tubuh"],
},
});
modul.ekspor = luwak.model("Blog", blogSchema);
Blok kode di atas membuat model luwak dengan dua properti dan memetakannya ke database MongoDB.
Kedua properti dalam model ini memiliki Rangkaian ketik dengan yg dibutuhkan mulai BENAR. Pesan kesalahan yang menyertainya akan ditampilkan jika badan permintaan tidak berisi salah satu properti.
Baris terakhir membuat dan mengekspor model luwak dengan memanggil model metode aktif luwak. Lewati nama model (Blog) sebagai argumen pertama dan skema (blogSkema) sebagai argumen kedua.
Langkah 4: Menerapkan Perutean di Aplikasi Anda
Tanpa bantuan kerangka kerja seperti Express, Anda harus membuat logika secara manual untuk menangani setiap permintaan yang dibuat ke API Anda.
Pertama, buat blogRoutes.js file di Anda rute folder, lalu impor model blog:
konstan Blog = memerlukan("../model/blogModel");
Selanjutnya, buat asinkron router fungsi, lulus permintaan dan res sebagai parameter, dan ekspor fungsinya:
konstan router = tidak sinkronfungsi (permintaan, res) {};
modul.ekspor = ruter;
Fungsi ini akan berisi semua logika perutean Anda.
Selanjutnya, Anda akan menerapkan logika perutean rute demi rute.
DAPATKAN Rute
Tambahkan blok kode di bawah ini ke router berfungsi untuk mengimplementasikan DAPATKAN pengendali rute untuk permintaan yang dibuat ke /api/blogs:
// DAPATKAN: /api/blogs
jika (req.url "/api/blogs"&& req.method "DAPATKAN") {
// dapatkan semua blog
konstan blog = menunggu Blog.temukan();// mengatur itu status kode danisi-Tipe
res.writeHead (200, { "Jenis konten": "aplikasi/json" });
// kirim data
res.akhir(JSON.stringify(blog));
}
Blok kode di atas memeriksa url dan metode properti dari objek permintaan. Kemudian mengambil semua blog dari database melalui Temukan metode pada model luwak (Blog).
Selanjutnya, ia memanggil menulisKepala metode aktif res, objek respon. Metode ini mengirimkan header respons yang diberikan tiga argumen: kode status, pesan status opsional, dan header. Itu 200 kode status mewakili respons yang berhasil dan tipe konten untuk panggilan API ini disetel ke aplikasi/json.
Terakhir, tutup permintaan untuk memastikan server tidak hang dengan memanggil akhir metode aktif res. Panggilan untuk JSON.stringify mengubah blog objek ke string JSON dan meneruskannya ke akhir metode mengembalikannya sebagai badan respons.
Tambahkan blok kode di bawah ini ke router berfungsi untuk mengimplementasikan DAPATKAN penangan rute untuk satu sumber daya:
// DAPATKAN: /api/blogs/:id
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && req.method "DAPATKAN") {
mencoba {
// ekstrak id dari url
const id = req.url.split("/")[3];// dapatkan blog dari DB
konstan blog = menunggu Blog.findById (id);
jika (blog) {
res.writeHead (200, { "Jenis konten": "aplikasi/json" });
res.akhir(JSON.stringify(blog));
} kalau tidak {
melemparkanbaruKesalahan("Blog tidak ada");
}
} menangkap (kesalahan) {
res.writeHead (404, { "Jenis konten": "aplikasi/json" });
res.akhir(JSON.stringify({ pesan: kesalahan }));
}
}
Kode ini menggunakan cocok metode, yang menggunakan ekspresi regex sebagai argumen, untuk memeriksa apakah url cocok dengan format: /api/blogs/.
Selanjutnya, ekstrak Indo properti dari url string dengan memanggilnya membelah metode. Metode ini mengambil pola sebagai argumen (/), membagi string berdasarkan pola, dan mengembalikan array. Elemen ketiga dari array itu adalah Indo.
Akhirnya, ambil dokumen dengan yang cocok Indo dari basis data Anda. Jika ada, kirimkan kode respon 200, tutup permintaan, dan kirim blog yang diambil. Jika tidak ada, lempar kesalahan dan kirimkan sebagai respons di blok tangkap.
Rute POSTING
Tambahkan blok kode di bawah ini ke fungsi router Anda untuk mengimplementasikan POS pengendali rute:
// POSTING: /api/blogs/
jika (req.url "/api/blogs"&& req.method "POS") {
mencoba {
biarkan tubuh = "";// Dengarkan acara data
req.on("data", (potongan) => {
tubuh += chunk.toString();
});// Dengarkan akhirperistiwa
req.on("akhir", asinkron () => {
// Buat Blog
membiarkan blog = baru Blog(JSON.parse (isi));
// Simpan ke DB
menunggu blog.simpan();
res.writeHead (200, { "Jenis konten": "aplikasi/json" });
res.akhir(JSON.stringify(blog));
});
} menangkap (kesalahan) {
menghibur.log (kesalahan);
}
}
Objek permintaan mengimplementasikan Node.js ReadableStream antarmuka. Aliran ini memancarkan data dan akhir acara yang memberi Anda akses ke data dari badan permintaan.
Kode ini mendengarkan peristiwa data dan menanganinya dengan mengubahnya menjadi string dan menggabungkannya ke tubuh variabel. Dalam akhir event handler, itu menciptakan a Blog contoh dengan string tubuh yang diurai. Ini kemudian menyimpan blog baru, mengirim kode status dan header konten, dan menutup permintaan.
Rute PUT
Tambahkan blok kode di bawah ini ke fungsi router Anda untuk mengimplementasikan TARUH pengendali rute:
// PUT: /api/blogs/:id
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && req.method "TARUH") {
mencoba {
// ekstrak id dari url
const id = req.url.split("/")[3];
biarkan tubuh = "";req.on("data", (potongan) => {
tubuh += chunk.toString();
});
req.on("akhir", asinkron () => {
// Temukan dan memperbaruidokumen
membiarkan updateBlog = menunggu Blog.findByIdAndUpdate (id, JSON.parse (isi), {
baru: BENAR,
});
res.writeHead (200, { "Jenis konten": "aplikasi/json" });
res.akhir(JSON.stringify(updateBlog));
});
} menangkap (kesalahan) {
menghibur.log (kesalahan);
}
}
Penangan permintaan PUT hampir identik dengan POS penangan permintaan, kecuali bahwa itu mengekstrak Indo properti dari url untuk memperbarui blog yang relevan.
HAPUS Rute
Tambahkan blok kode di bawah ini ke fungsi router Anda untuk mengimplementasikan MENGHAPUS pengendali rute:
// MENGHAPUS: /api/blog/:Indo
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && req.method "MENGHAPUS") {
mencoba {
const id = req.url.split("/")[3];
// Menghapus blog dari DB
menunggu Blog.findByIdAndDelete (id);
res.writeHead (200, { "Jenis konten": "aplikasi/json" });
res.end (JSON.stringify({ pesan: "Blog berhasil dihapus" }));
} menangkap (kesalahan) {
res.writeHead (404, { "Jenis konten": "aplikasi/json" });
res.akhir(JSON.stringify({ pesan: kesalahan }));
}
}
Blok kode ini mengekstrak Indo dari url, menghapus dokumen dengan yang cocok Indo, mengirimkan kode status dan header, dan menutup permintaan.
Akhirnya, impor router di kamu server.js arsipkan dan hubungi Anda router fungsi, lulus permintaan dan res sebagai argumen:
konstan router = memerlukan("./routes/blogRoutes");
konstan server = http.createServer((req, res) => {
router (permintaan, res);
});
Ini memungkinkan server Anda untuk mencegat dan menangani permintaan dengan tepat.
Anda dapat menemukan proyek yang telah selesai di sini Repositori GitHub.
Menggunakan Kerangka Node.js
Meskipun mungkin untuk membuat web API dengan tangan, itu bisa menjadi tugas yang sulit. Anda harus memastikan bahwa Anda telah membahas banyak kasus tepi dan kode Anda sebaiknya bebas bug.
Selama bertahun-tahun, pengembang telah membangun kerangka kerja seperti ExpressJS, NestJS, Fastify, dll., untuk membuatnya lebih mudah.
