Hijr Ismail

Metode yang digunakan untuk menangani data yang diterima dari Promise adalah:

1. then(): Digunakan untuk menangani resolusi (sukses) dari Promise.
2. catch(): Digunakan untuk menangani penolakan (gagal) dari Promise.
3. finally(): Digunakan untuk menjalankan kode setelah Promise diselesaikan, baik dalam kondisi berhasil maupun gagal.

Berikut adalah contoh penggunaan masing-masing metode:

1. then()

then() digunakan untuk menjalankan fungsi callback ketika Promise berhasil diselesaikan (fulfilled).

javascript
Copy code
let promise = new Promise((resolve, reject) => {
  resolve('Data received successfully');
});

promise.then(data => {
  console.log(data); // Output: Data received successfully
});

2. catch()

catch() digunakan untuk menjalankan fungsi callback ketika Promise ditolak (rejected).

javascript
Copy code
let promise = new Promise((resolve, reject) => {
  reject('Error in data retrieval');
});

promise.catch(error => {
  console.error(error); // Output: Error in data retrieval
});

3. finally()

finally() digunakan untuk menjalankan fungsi callback setelah Promise selesai, baik itu dalam kondisi berhasil (fulfilled) maupun gagal (rejected).

javascript
Copy code
let promise = new Promise((resolve, reject) => {
  resolve('Data received successfully');
});

promise
  .then(data => {
    console.log(data); // Output: Data received successfully
  })
  .catch(error => {
    console.error(error);
  })
  .finally(() => {
    console.log('Promise has been handled.'); // Output: Promise has been handled.
  });

Menggunakan Async/Await

Selain metode di atas, Anda juga dapat menggunakan async/await untuk menangani Promise. Ini memberikan cara yang lebih bersih dan sinkron untuk bekerja dengan Promise.

javascript
Copy code
async function fetchData() {
  try {
    let data = await promise;
    console.log(data); // Output: Data received successfully
  } catch (error) {
    console.error(error);
  } finally {
    console.log('Promise has been handled.'); // Output: Promise has been handled.
  }
}

let promise = new Promise((resolve, reject) => {
  resolve('Data received successfully');
});

fetchData();

Dengan menggunakan metode then(), catch(), dan finally(), serta pendekatan async/await, Anda dapat dengan efektif menangani data yang diterima dari Promise dan mengelola alur program secara asinkron.

Menggunakan modul dalam proyek JavaScript memberikan berbagai keuntungan yang membantu dalam pengelolaan, pengembangan, dan pemeliharaan kode. Berikut adalah beberapa alasan utama untuk menerapkan modul pada proyek JavaScript:

1. Encapsulation:

   • Modul membantu dalam memisahkan dan mengisolasi kode, sehingga variabel dan fungsi yang didefinisikan dalam satu modul tidak tercampur dengan modul lain. Ini mencegah konflik nama dan membantu menjaga kebersihan namespace.

2. Reusability:

   • Dengan memecah kode menjadi modul, Anda dapat dengan mudah menggunakan kembali kode di berbagai bagian proyek atau bahkan di proyek lain. Modul yang dirancang dengan baik bisa menjadi komponen yang dapat digunakan kembali.

3. Maintainability:

   • Memisahkan kode ke dalam modul yang lebih kecil dan terfokus membuatnya lebih mudah untuk memahami, menguji, dan memelihara. Ini memungkinkan pengembang untuk bekerja pada bagian kode tertentu tanpa harus memahami seluruh kode basis.

4. Dependency Management:

   • Modul membantu dalam mengelola ketergantungan dengan jelas. Anda dapat dengan mudah melihat modul mana yang tergantung pada modul lain dan mengontrol versi serta pembaruan ketergantungan dengan lebih efektif.

5. Namespace Management:

   • Modul mencegah polusi global namespace dengan membatasi ruang lingkup variabel dan fungsi ke dalam modul itu sendiri. Ini membantu menghindari konflik dan membuat kode lebih aman.

6. Testing:

   • Modul memfasilitasi pengujian unit karena modul yang lebih kecil dan terfokus lebih mudah untuk diuji secara individual. Ini meningkatkan keandalan dan kualitas kode.

7. Code Splitting:

   • Dalam aplikasi besar, Anda dapat membagi kode menjadi bagian-bagian yang lebih kecil dan hanya memuat modul yang diperlukan. Ini mengurangi waktu muat awal dan meningkatkan kinerja aplikasi.

8. Scalability:

   • Modul membuat proyek lebih mudah untuk diskalakan. Anda dapat menambahkan fitur baru atau memperluas fungsionalitas tanpa harus mengubah struktur keseluruhan kode.

9. Collaboration:

   • Dengan modul, beberapa pengembang dapat bekerja pada bagian berbeda dari proyek tanpa banyak konflik. Modul yang terisolasi mengurangi risiko gangguan satu sama lain.

10. Standardization:

    • JavaScript ES6+ menyediakan dukungan untuk modul standar (ES Modules) dengan kata kunci import dan export, yang meningkatkan interoperabilitas dan memanfaatkan fitur modern bahasa.

Berikut adalah contoh sederhana penggunaan modul ES6:

math.js (modul)

javascript
Copy code
export function add(a, b) {
  return a + b;
}

export function subtract(a, b) {
  return a - b;
}

main.js (mengimpor dan menggunakan modul)

javascript
Copy code
import { add, subtract } from './math.js';

console.log(add(2, 3)); // 5
console.log(subtract(5, 2)); // 3

Dengan menggunakan modul, kode menjadi lebih terstruktur, terorganisir, dan lebih mudah dikelola, yang sangat penting untuk proyek-proyek JavaScript berskala besar dan kompleks.

Untuk menangani kondisi onRejected (penolakan) dalam sintaksis async-await di JavaScript, Anda dapat menggunakan blok try...catch. Pendekatan ini memungkinkan Anda menangkap dan menangani kesalahan yang terjadi saat menjalankan operasi asynchronous yang mungkin melemparkan error.

Berikut adalah contoh cara menangani penolakan menggunakan try...catch:

javascript
Copy code
async function fetchData() {
  try {
    const response = await fetch('https://api.example.com/data');
    const data = await response.json();
    console.log(data);
  } catch (error) {
    console.error('Error occurred:', error);
  }
}

fetchData();

Dalam contoh ini, jika permintaan fetch gagal atau ada masalah saat mengubah respons menjadi JSON, error tersebut akan ditangkap oleh blok catch, dan Anda bisa menanganinya (misalnya dengan mencetak pesan kesalahan ke konsol).

Selain itu, Anda juga dapat menggunakan try...catch bersarang jika Anda perlu menangani beberapa bagian dari kode asynchronous secara berbeda:

javascript
Copy code
async function fetchData() {
  try {
    const response = await fetch('https://api.example.com/data');
    if (!response.ok) {
      throw new Error('Network response was not ok');
    }
    try {
      const data = await response.json();
      console.log(data);
    } catch (jsonError) {
      console.error('Failed to parse JSON:', jsonError);
    }
  } catch (networkError) {
    console.error('Fetch error:', networkError);
  }
}

fetchData();

Dalam contoh ini, kesalahan jaringan dan kesalahan parsing JSON ditangani secara terpisah untuk memberikan respons yang lebih spesifik tergantung pada jenis kesalahan yang terjadi.

Dengan menggunakan blok try...catch, Anda dapat dengan mudah mengelola kesalahan dalam fungsi asynchronous, memberikan pengalaman pengguna yang lebih baik dengan menangani dan melaporkan kesalahan secara tepat.