Cara Mengelola Error Handling di JavaScript dengan Rapi dan Efektif (Panduan Developer Modern)

Dalam pengembangan aplikasi JavaScript, baik di frontend dengan framework modern maupun di backend dengan Node.js, error adalah bagian tak terhindarkan. Kode yang sempurna tanpa bug mungkin hanya ada di dunia ideal. Namun, yang membedakan aplikasi yang robust dan mudah dikelola dengan aplikasi yang rapuh adalah bagaimana kita mengelola error-error tersebut.

Seringkali, saya melihat project yang error handling-nya terabaikan, atau kalaupun ada, implementasinya acak-acakan. Akibatnya, aplikasi sering crash tanpa pesan yang jelas, pengguna mendapatkan pengalaman yang buruk, dan proses debugging menjadi mimpi buruk bagi developer. Padahal, dengan strategi yang tepat, kita bisa membuat error handling menjadi bagian yang bersih, prediktif, dan membantu dalam pengembangan.

Artikel ini akan memandu Anda memahami berbagai aspek error handling di JavaScript, mulai dari dasar-dasar try...catch, asynchronous error handling, hingga strategi tingkat lanjut seperti custom error dan global error handling. Kita akan membahas praktik terbaik, kesalahan umum, dan bagaimana mengintegrasikannya dalam workflow pengembangan modern Anda agar kode lebih rapi, tahan banting, dan mudah di-maintain.

Mengapa Error Handling Penting? Lebih dari Sekadar Mencegah Crash

Mungkin ada yang berpikir, “Ah, kalau error ya sudah, nanti juga ketemu pas testing.” Sayangnya, pendekatan seperti itu bisa sangat merugikan. Error handling yang baik bukan hanya tentang mencegah aplikasi crash, tetapi juga tentang:

• Meningkatkan User Experience (UX): Pengguna tidak suka aplikasi yang tiba-tiba berhenti atau menampilkan pesan error yang tidak jelas. Error handling yang baik memungkinkan kita menampilkan pesan yang user-friendly atau melakukan graceful degradation.
• Mempermudah Debugging: Dengan pesan error yang terstruktur dan logging yang tepat, developer bisa dengan cepat mengidentifikasi letak dan penyebab masalah, mengurangi waktu dan frustrasi saat debugging.
• Meningkatkan Stabilitas dan Keamanan Aplikasi: Error yang tidak tertangani bisa membuka celah keamanan atau menyebabkan aplikasi berada dalam kondisi yang tidak konsisten, yang berpotensi merusak data atau menyebabkan downtime.
• Menjaga Integritas Data: Dalam aplikasi backend, error yang tidak ditangani dengan baik saat operasi database bisa menyebabkan data corrupt atau transaksi yang tidak lengkap.
• Membangun Kepercayaan: Aplikasi yang stabil dan responsif membangun kepercayaan pengguna. Ini krusial, terutama untuk aplikasi bisnis atau layanan penting.

Dasar-Dasar Error Handling: try...catch dan finally

Pondasi error handling di JavaScript adalah blok try...catch. Ini adalah mekanisme sinkron untuk “mencoba” menjalankan sepotong kode dan “menangkap” error yang mungkin terjadi di dalamnya.

Bagaimana Cara Kerja try...catch?

Sintaksnya cukup sederhana:

try {
// Kode yang berpotensi menimbulkan error
// Misalnya, memanggil fungsi yang tidak ada, mengakses properti undefined
} catch (error) {
// Kode ini akan dieksekusi jika terjadi error di blok 'try'
// 'error' adalah objek yang berisi detail tentang error tersebut
}

Contoh Sederhana:

function bagiAngka(a, b) {
if (b === 0) {
throw new Error("Pembagian dengan nol tidak diizinkan.");
}
return a / b;
}

try {
const hasil = bagiAngka(10, 0);
console.log("Hasil:", hasil);
} catch (e) {
console.error("Terjadi kesalahan:", e.message); // Output: Terjadi kesalahan: Pembagian dengan nol tidak diizinkan.
}

Peran Blok finally

Blok finally bersifat opsional dan akan selalu dieksekusi, terlepas dari apakah ada error yang terjadi di blok try atau tidak. Ini sangat berguna untuk membersihkan sumber daya (resource cleanup) seperti menutup koneksi database, file, atau membebaskan memori.

try {
// Kode yang berpotensi error
// Misalnya, membuka koneksi ke database
} catch (error) {
// Penanganan error
} finally {
// Kode ini selalu dieksekusi
// Misalnya, menutup koneksi database, membersihkan variabel
}

Contoh dengan finally:

let fileHandle = null;
try {
fileHandle = openFile("data.txt"); // Anggap fungsi ini membuka file
// Lakukan operasi dengan fileHandle
// ...
// Mungkin terjadi error di sini
} catch (e) {
console.error("Gagal memproses file:", e.message);
} finally {
if (fileHandle) {
closeFile(fileHandle); // Anggap fungsi ini menutup file
console.log("File berhasil ditutup.");
}
}

Memahami Jenis-Jenis Error Bawaan JavaScript

JavaScript memiliki beberapa jenis objek Error bawaan yang membantu kita mengidentifikasi masalah lebih spesifik. Semua objek error ini mewarisi dari objek dasar Error.

• Error: Ini adalah objek dasar untuk semua error. Biasanya digunakan untuk error umum atau ketika tidak ada jenis error yang lebih spesifik.
• TypeError: Terjadi ketika suatu nilai tidak dari tipe yang diharapkan. Contoh: memanggil method pada `null` atau `undefined`.
• ReferenceError: Terjadi ketika mencoba mengakses variabel yang belum dideklarasikan atau tidak ada dalam scope.
• SyntaxError: Terjadi ketika ada kesalahan sintaks dalam kode, dan interpreter tidak bisa mem-parsing-nya. Biasanya terjadi saat kode di-load atau dievaluasi.
• RangeError: Terjadi ketika nilai berada di luar rentang yang diizinkan (misalnya, membuat array dengan panjang negatif).
• URIError: Terjadi saat fungsi global URI (seperti decodeURI()) digunakan secara tidak valid.
• EvalError: Terjadi saat terjadi error pada fungsi eval(). (Jarang digunakan dan tidak direkomendasikan).

Membedakan jenis error ini sangat membantu saat debugging dan memutuskan bagaimana menanganinya. Misalnya, TypeError seringkali menunjukkan masalah di logic atau asumsi tipe data, sedangkan ReferenceError bisa berarti typo pada nama variabel.

Error Handling dalam Asynchronous JavaScript

Salah satu tantangan terbesar dalam error handling JavaScript adalah sifat asinkronnya. Metode try...catch tradisional tidak bisa langsung menangkap error yang terjadi di dalam callback fungsi asinkron atau promise, karena eksekusi kode sudah keluar dari blok try...catch saat error tersebut muncul.

Callbacks (Error-First Callback)

Pola lama yang umum di Node.js adalah “error-first callback”. Parameter pertama dari callback selalu disediakan untuk objek error.

function fetchData(callback) {
setTimeout(() => {
const success = Math.random() > 0.5;
if (success) {
callback(null, { id: 1, name: "Data Contoh" });
} else {
callback(new Error("Gagal mengambil data dari server."), null);
}
}, 1000);
}

fetchData((error, data) => {
if (error) {
console.error("Terjadi error pada callback:", error.message);
return;
}
console.log("Data berhasil diambil:", data);
});

Promises (`.catch()`)

Promises merevolusi cara kita menangani asynchronicity dan juga error. Setiap promise memiliki method .catch() yang dirancang khusus untuk menangani error yang terjadi selama rantai promise.

function fetchDataPromise() {
return new Promise((resolve, reject) => {
setTimeout(() => {
const success = Math.random() > 0.5;
if (success) {
resolve({ id: 2, name: "Data Promise" });
} else {
reject(new Error("Gagal mengambil data dari promise."));
}
}, 1000);
});
}

fetchDataPromise()
.then(data => {
console.log("Data Promise berhasil diambil:", data);
return data.id * 2; // Mungkin ada error di sini jika data.id undefined
})
.then(processedData => {
console.log("Data diproses:", processedData);
})
.catch(error => {
console.error("Terjadi error pada promise:", error.message);
});

Async/Await dengan try...catch

Ini adalah pendekatan modern dan yang paling direkomendasikan karena mengembalikan kemudahan try...catch ke dalam kode asinkron, membuatnya terlihat seperti kode sinkron.

async function processDataAsync() {
try {
const data = await fetchDataPromise();
console.log("Data Async/Await berhasil diambil:", data);
const processedData = data.id * 2;
console.log("Data Async/Await diproses:", processedData);
} catch (error) {
console.error("Terjadi error pada async/await:", error.message);
}
}

processDataAsync();

Pendekatan async/await sangat membersihkan kode dan membuat alur error handling lebih intuitif. Ingat, fungsi yang menggunakan await harus didefinisikan sebagai async, dan setiap blok await harus berada dalam try...catch jika Anda ingin menangani error-nya secara spesifik.

Strategi Tingkat Lanjut untuk Penanganan Error yang Lebih Baik

Error Propagasi: Melemparkan Error dengan Tepat

Tidak semua error perlu ditangani di tempat ia terjadi. Terkadang, kita ingin “melemparkan” kembali error tersebut ke lapisan yang lebih tinggi dalam aplikasi untuk penanganan yang lebih kontekstual atau global. Ini disebut error propagasi.

Misalnya, sebuah fungsi utilitas mungkin menangkap error untuk melakukan logging, tetapi kemudian melemparkannya kembali agar fungsi pemanggil bisa menampilkan pesan ke user atau melakukan rollback transaksi.

function ambilDariDatabase(query) {
try {
// Logika akses database
// ...
throw new Error("Koneksi database terputus!"); // Simulasikan error
} catch (e) {
console.error("Kesalahan internal saat query:", e.message);
throw e; // Penting: Lempar kembali error agar pemanggil bisa menanganinya
}
}

async function tampilkanDataPengguna() {
try {
const data = await ambilDariDatabase("SELECT * FROM users");
console.log("Data pengguna:", data);
} catch (e) {
console.error("Gagal menampilkan data pengguna:", e.message);
// Di sini kita bisa menampilkan pesan error ke user
document.getElementById("error-message").innerText = "Maaf, data tidak bisa dimuat.";
}
}

Propagasi error memastikan bahwa error tidak “hilang” di tengah jalan dan ditangani pada level yang paling relevan.

Membuat Custom Error: Untuk Skenario Aplikasi Spesifik

Error bawaan JavaScript seringkali kurang spesifik untuk kebutuhan aplikasi yang kompleks. Misalnya, Anda mungkin ingin membedakan antara “Error Validasi Input”, “Error Otentikasi”, atau “Error Database”. Di sinilah custom error berperan.

Dengan membuat class error kita sendiri yang mewarisi dari Error, kita bisa menambahkan properti tambahan dan memberikan identifikasi yang lebih jelas.

class ValidationError extends Error {
constructor(message, field) {
super(message);
this.name = "ValidationError";
this.field = field;
}
}

class AuthenticationError extends Error {
constructor(message) {
super(message);
this.name = "AuthenticationError";
this.statusCode = 401;
}
}

function validateUserData(userData) {
if (!userData.email || !userData.email.includes('@')) {
throw new ValidationError("Format email tidak valid.", "email");
}
// ... validasi lainnya
return true;
}

try {
validateUserData({ username: "john" });
} catch (e) {
if (e instanceof ValidationError) {
console.error(`Validasi gagal pada bidang '${e.field}': ${e.message}`);
} else {
console.error("Terjadi error tak terduga:", e.message);
}
}

Custom error membuat kode lebih ekspresif dan memudahkan penanganan error berdasarkan jenisnya.

Global Error Handling: Jangan Biarkan Error Tak Tertangkap

Meskipun try...catch dan .catch() sangat penting, ada kalanya error luput dari penanganan lokal. Untuk skenario ini, kita bisa mengatur penanganan error global sebagai “jaring pengaman” terakhir.

Di Browser (Frontend)

• window.onerror: Menangkap error yang tidak tertangani dalam kode sinkron.
• window.addEventListener('unhandledrejection', ...): Menangkap promise yang di-reject tetapi tidak memiliki handler .catch().

window.onerror = function(message, source, lineno, colno, error) {
console.error("Error Global (Sinkron):", message, error);
// Kirim error ke layanan monitoring
return true; // Mencegah error default browser
};

window.addEventListener('unhandledrejection', function(event) {
console.error("Error Global (Promise):", event.reason);
// Kirim error ke layanan monitoring
});

Di Node.js (Backend)

• process.on('uncaughtException', ...): Menangkap error yang tidak tertangani dan di-throw secara sinkron.
• process.on('unhandledRejection', ...): Menangkap promise yang di-reject tetapi tidak memiliki handler .catch().

process.on('uncaughtException', (err) => {
console.error('Ada Uncaught Exception:', err.message, err.stack);
// Lakukan cleanup, log, lalu matikan aplikasi secara graceful
process.exit(1); // Sangat penting untuk keluar dari proses setelah uncaught exception
});

process.on('unhandledRejection', (reason, promise) => {
console.error('Unhandled Rejection pada Promise:', reason, promise);
// Biasanya cukup log, tidak perlu keluar dari proses secara paksa
});

Penting: Global error handling seharusnya menjadi fallback, bukan pengganti penanganan error di lokasi yang relevan. Saat uncaughtException terjadi di Node.js, aplikasi Anda berada dalam kondisi yang tidak pasti, jadi praktik terbaik adalah log error tersebut dan kemudian menghentikan aplikasi secara paksa (process.exit(1)) dan mengandalkan proses manager (PM2, Kubernetes) untuk me-restart-nya.

Best Practices untuk Kode yang Bersih dan Tahan Banting

Jangan Menelan Error (Don’t Swallow Errors)

Salah satu kesalahan paling umum adalah menangkap error dan tidak melakukan apa-apa dengannya, atau hanya menampilkan pesan generik di console. Ini disebut “menelan error”.

try {
// ... kode
} catch (e) {
// Jangan lakukan ini!
console.log("Terjadi error."); // Pesan tidak informatif, tidak ada tindakan lain.
}

Menelan error membuat debugging sangat sulit karena Anda kehilangan jejak masalah. Jika Anda menangkap error, selalu ada alasan untuk itu: logging, menampilkan pesan ke user, memulihkan kondisi, atau melemparkannya kembali.

Logging Error yang Informatif

Log adalah mata dan telinga aplikasi Anda. Saat error terjadi, pastikan Anda mencatat informasi yang cukup:

• Pesan Error: Dari objek error.message.
• Stack Trace: Dari objek error.stack, ini penting untuk mengetahui di mana error terjadi.
• Context Data: Variabel-variabel relevan, ID pengguna, payload request, dll., yang dapat membantu mereproduksi atau memahami error.
• Timestamp: Kapan error terjadi.

Gunakan console.error() untuk pesan error di development. Untuk produksi, integrasikan dengan layanan monitoring error seperti Sentry, Bugsnag, atau LogRocket yang bisa mengumpulkan, menganalisis, dan memberikan notifikasi error secara real-time.

Memberikan Pesan Error yang Jelas dan Informatif

Pesan error harus berguna untuk dua audiens berbeda: developer dan pengguna akhir.

• Untuk Developer: Pesan harus teknis, mengandung detail seperti nama file, baris kode, nilai variabel, dan stack trace.
• Untuk Pengguna: Pesan harus sederhana, tidak teknis, dan memberikan instruksi yang jelas (misalnya, “Terjadi kesalahan saat memuat data. Mohon coba lagi nanti.” atau “Pastikan semua kolom sudah diisi dengan benar.”).

Hindari menampilkan stack trace ke pengguna akhir, karena ini bisa menjadi celah keamanan dan membingungkan.

Pilah Error Berdasarkan Kategori/Severity

Tidak semua error memiliki tingkat urgensi yang sama. Error validasi input mungkin hanya butuh pesan ke user, sementara error koneksi database mungkin butuh notifikasi ke tim ops dan retry mechanism.

Gunakan custom error atau periksa instanceof ErrorType untuk membedakan error dan menanganinya secara spesifik. Ini membantu dalam memutuskan respons aplikasi dan siapa yang perlu diberitahu.

Pisahkan Logic Bisnis dari Logic Error Handling

Usahakan agar kode bisnis Anda tetap fokus pada domain masalahnya. Logic untuk menangani error (misalnya, menampilkan pesan, logging, retry) sebaiknya dipisahkan ke modul atau lapisan khusus. Ini meningkatkan keterbacaan dan modularitas kode.

Test Error Handling Anda

Percayalah, error handling Anda bisa saja memiliki bug! Pastikan Anda menulis unit dan integration test untuk skenario error. Uji:

• Apakah error yang diharapkan muncul?
• Apakah error ditangani dengan benar (misalnya, pesan error yang benar ditampilkan, logging terjadi)?
• Apakah aplikasi pulih dengan baik setelah error?

Pengalaman dan Pertimbangan Praktis di Dunia Nyata

Frontend vs. Backend: Perbedaan Pendekatan

Meskipun prinsip dasar sama, implementasi error handling di frontend dan backend punya fokus berbeda:

• Frontend: Prioritas utama adalah pengalaman pengguna. Menangkap error untuk mencegah UI crash, menampilkan pesan user-friendly, dan graceful degradation. Logging penting untuk analisis di kemudian hari.
• Backend: Prioritas utama adalah stabilitas server, integritas data, dan keamanan. Error harus ditangkap dan di-log secara detail, seringkali dengan notifikasi ke tim ops. Penanganan error di backend bisa melibatkan retry mechanism, circuit breakers, atau bahkan mematikan proses untuk di-restart oleh process manager.

Over-handling vs. Under-handling: Mencari Keseimbangan

Ada kalanya developer terlalu obsesif dengan try...catch di mana-mana, membuat kode jadi bertele-tele. Di sisi lain, ada yang sama sekali tidak peduli. Keseimbangan itu kunci.

• Under-handling: Fatal, karena aplikasi akan sering crash dan sulit di-debug.
• Over-handling: Bisa menambah kompleksitas yang tidak perlu. Tidak semua baris kode butuh try...catch individual. Fokus pada batasan (boundaries) antara modul, input/output dari API, atau operasi yang berpotensi gagal (IO, network, database).

Dampak Terhadap Performa

Secara umum, overhead dari try...catch atau mekanisme error handling lainnya di JavaScript modern sangat minimal dan tidak akan menjadi bottleneck performa kecuali Anda menangkap dan melempar ribuan error dalam loop yang sangat intensif. Fokuslah pada kejelasan, stabilitas, dan maintainability terlebih dahulu.

Cost of Complexity

Sistem error handling yang terlalu rumit bisa jadi bumerang. Jika Anda memiliki terlalu banyak custom error yang sangat spesifik, atau logic penanganan error yang berlapis-lapis, kode Anda mungkin akan lebih sulit dipahami dan di-maintain. Buatlah sesederhana mungkin untuk memenuhi kebutuhan aplikasi Anda.

Integrasi dengan Tools Monitoring

Dalam project sungguhan, terutama yang sudah production, mengandalkan console.error saja tidak cukup. Integrasikan dengan tools monitoring seperti Sentry, Datadog, New Relic, atau ELK stack. Tools ini akan mengumpulkan semua error, menyediakan stack trace yang interaktif, mengelompokkan error serupa, dan memberi tahu Anda secara real-time ketika ada masalah.

Masalah yang Sering Terjadi dalam Error Handling JavaScript

Error di Promise Tidak Tertangkap

Ini adalah salah satu masalah klasik yang sering membuat frustrasi. Jika sebuah promise di-reject dan tidak ada handler .catch() di rantainya, error tersebut akan menjadi unhandled rejection. Di Node.js, ini bisa berakibat fatal jika tidak ada process.on('unhandledRejection').

function willFail() {
return new Promise((resolve, reject) => {
setTimeout(() => reject(new Error("Gagal di promise!")), 100);
});
}

willFail(); // Error ini tidak akan tertangkap oleh try...catch di luar, dan jika tidak ada .catch(), akan menjadi unhandled rejection.

Solusi: Selalu akhiri rantai promise dengan .catch(), atau gunakan async/await dengan try...catch.

Callback Hell dengan Error Handling

Dalam kode lama yang banyak menggunakan nested callback, menambahkan error handling untuk setiap callback bisa membuat kode sangat panjang dan tidak terbaca.

function step1(cb) {
// ...
step2((err, data2) => {
if (err) return cb(err);
// ...
step3((err, data3) => {
if (err) return cb(err);
// ... dan seterusnya
});
});
}

Solusi: Refactor ke Promises atau async/await. Ini adalah salah satu alasan utama mengapa Promises dan async/await diciptakan.

Custom Error yang Tidak Benar

Kadang, developer membuat custom error tanpa mewarisi dari class Error, atau lupa memanggil super(message) di constructor-nya. Ini bisa menyebabkan stack trace yang hilang atau properti error dasar yang tidak tersedia.

class MyBadError { // Kesalahan: Tidak extends Error
constructor(message) {
this.message = message;
this.name = "MyBadError";
}
}

Solusi: Pastikan setiap custom error Anda extends Error dan memanggil super(message) di constructor.

Menelan Error Secara Diam-Diam

Seperti yang sudah dibahas, ini adalah kebiasaan buruk yang harus dihindari. Kode Anda mungkin terlihat “berjalan”, tetapi sebenarnya ada masalah yang tersembunyi, menunggu untuk muncul di saat yang paling tidak tepat.

Solusi: Jangan pernah membiarkan blok catch kosong atau hanya berisi console.log() generik. Minimal log error dengan detail lengkap dan pikirkan tindakan selanjutnya (propagasi, notifikasi, pesan user).

Menangani Error yang Sama Berulang Kali

Jika Anda menemukan diri Anda menulis blok try...catch yang identik di banyak tempat, itu pertanda Anda perlu merangkumnya menjadi fungsi utilitas atau menggunakan pendekatan yang lebih terpusat (seperti middleware di Express.js, atau error boundary di React).

Solusi: Identifikasi pola error handling yang berulang dan buat abstraksi untuk itu. Misalnya, sebuah fungsi wrapAsync(fn) untuk route handler Express yang secara otomatis menangani error promise.

FAQ

Q: Kapan saya harus menggunakan throw?

Anda harus menggunakan throw ketika kondisi yang tidak dapat dipulihkan terjadi dalam sebuah fungsi, dan fungsi tersebut tidak tahu bagaimana cara menanganinya. Melemparkan error memungkinkan fungsi pemanggil (atau lapisan yang lebih tinggi) untuk menanganinya. Contoh: validasi input yang gagal kritis, koneksi ke resource eksternal yang terputus, atau mencoba mengakses indeks array yang tidak ada secara fatal.

Q: Bisakah try...catch menangani semua jenis error?

try...catch efektif untuk error sinkron dan error di dalam blok async/await. Namun, ia tidak dapat menangani error yang terjadi di luar lingkup eksekusinya, seperti di dalam callback asinkron tradisional (tanpa Promise/async/await) atau unhandled promise rejection. Untuk itu, diperlukan mekanisme terpisah seperti .catch() pada Promises atau global error handler.

Q: Apakah custom error wajib?

Tidak wajib, terutama untuk project kecil. Anda bisa saja hanya menggunakan objek Error bawaan. Namun, custom error sangat direkomendasikan untuk project yang lebih besar dan kompleks karena meningkatkan kejelasan, mempermudah identifikasi masalah, dan memungkinkan penanganan error yang lebih spesifik dan terorganisir di berbagai bagian aplikasi Anda.

Q: Apa risiko terlalu banyak global error handling?

Mengandalkan global error handling sebagai satu-satunya strategi adalah berbahaya. Ketika error mencapai handler global, itu berarti error tersebut tidak ditangani di level yang relevan dan aplikasi mungkin sudah berada dalam kondisi yang tidak konsisten atau rusak. Di Node.js, uncaughtException seringkali berarti Anda harus mematikan proses, yang bisa mengganggu layanan. Global handler adalah jaring pengaman terakhir, bukan pengganti penanganan error di tempat yang tepat.

Kesimpulan

Mengelola error handling di JavaScript adalah seni dan sains. Ini bukan hanya tentang menangkap error untuk mencegah crash, tetapi juga tentang menciptakan pengalaman yang lebih baik bagi pengguna, mempermudah pekerjaan developer, dan memastikan stabilitas serta integritas aplikasi Anda.

Dengan menguasai dasar-dasar try...catch, memahami nuansa asynchronous error handling, dan menerapkan strategi tingkat lanjut seperti custom error dan propagasi, Anda bisa membangun aplikasi yang lebih tangguh dan mudah di-maintain. Selalu prioritaskan logging yang informatif, berikan pesan yang jelas, dan jangan pernah menelan error secara diam-diam. Dengan praktik-praktik ini, kode JavaScript Anda akan jauh lebih rapi, profesional, dan siap menghadapi tantangan di dunia nyata.

TAGS: JavaScript, Error Handling, Programming, Developer Tools, Coding Best Practices, Async/Await, Promises, try…catch, Software Engineering

---

Baca Juga

• Panduan Lengkap Belajar Coding untuk Pemula hingga Profesional