Scala for Backend Engineering & Functional Programming · Pelajaran

Menggabungkan Operasi Asinkron

Pelajari cara merangkai dan menggabungkan beberapa `Future` menggunakan metode seperti `map`, `flatMap`, dan pemahaman `for`.

Menggabungkan Operasi Asinkron adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 2 dari 3. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Scala for Backend Engineering & Functional Programming, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Scala for Backend Engineering & Functional Programming mencakup 3 pelajaran total.

Mengapa Merangkai Operasi Asinkron?

Future membantu kita menjalankan tugas tanpa memblokir program utama. Namun, bagaimana jika hasil dari satu tugas diperlukan oleh tugas lain, atau kita perlu menggabungkan hasil dari beberapa tugas?

Di sinilah komposisi Future berguna. Anda akan mempelajari cara merangkai dan menggabungkan operasi asinkron ini agar kode Scala Anda lebih bertenaga dan responsif.

`map`: Mengubah Hasil Future

Metode map digunakan ketika Anda memiliki Future dan ingin mengubah hasil suksesnya menjadi nilai lain. Fungsi transformasi yang Anda berikan akan diterapkan setelah Future selesai dengan sukses.

Metode ini selalu mengembalikan Future baru.
Metode ini cocok untuk transformasi sederhana dan sinkron pada hasil asinkron.

`map` dalam Praktik (Kode)

Di sini, kita mendapatkan angka dari sebuah Future, lalu menggandakannya menggunakan map. Transformasi dilakukan hanya setelah Future awal selesai.

import scala.concurrent.{Future, Await}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration._

object Main {
  def main(args: Array[String]): Unit = {
    val originalFuture: Future[Int] = Future {
      Thread.sleep(100) // Simulate work
      10
    }

    val doubledFuture: Future[Int] = originalFuture.map(value => value * 2)

    val result = Await.result(doubledFuture, 1.second)
    println(s"Doubled value: $result")
  }
}

`flatMap`: Merangkai Future

Terkadang, hasil sukses dari satu Future perlu memulai Future lain. Di sinilah flatMap sangat berguna. Metode ini "meratakan" Future yang berisi Future (Future[Future[T]]) menjadi satu Future[T].

Gunakan metode ini ketika fungsi transformasi Anda mengembalikan Future.
Metode ini penting untuk operasi asinkron berurutan.

`flatMap` dalam Praktik (Kode)

Kita mengambil ID pengguna, lalu menggunakan ID tersebut untuk mengambil detail pengguna. Setiap langkah merupakan operasi asinkron yang mengembalikan Future. flatMap memastikan langkah-langkah tersebut dijalankan secara berurutan.

import scala.concurrent.{Future, Await}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration._

object Main {
  def main(args: Array[String]): Unit = {
    def fetchUserId(): Future[Int] = Future {
      Thread.sleep(50)
      123
    }

    def fetchUserDetails(userId: Int): Future[String] = Future {
      Thread.sleep(100)
      s"User $userId details"
    }

    val userDetailsFuture: Future[String] = fetchUserId().flatMap { userId =>
      fetchUserDetails(userId)
    }

    val result = Await.result(userDetailsFuture, 1.second)
    println(s"Details: $result")
  }
}

`map` vs. `flatMap`: Perbedaan Utama

Orang sering keliru membedakan map dan flatMap. Ingatlah:

map: Fungsi Anda mengembalikan nilai biasa (misalnya, Int, String). Future[A].map(A => B) menghasilkan Future[B].
flatMap: Fungsi Anda mengembalikan Future lain (misalnya, Future[Int], Future[String]). Future[A].flatMap(A => Future[B]) menghasilkan Future[B].

flatMap digunakan untuk merangkai operasi asinkron, sedangkan map digunakan untuk mengubah hasil asinkron secara sinkron.

Pemahaman `for`: Perangkaian yang Elegan

Pemahaman for di Scala menyediakan sintaks yang bersih dan mudah dibaca untuk merangkai operasi yang melibatkan map dan flatMap. Ini hanyalah gula sintaksis, yang berarti kompiler menerjemahkannya menjadi serangkaian pemanggilan map, flatMap, dan filter.

Ketika Anda memiliki beberapa operasi Future yang saling bergantung, pemahaman for membuat kode terlihat hampir seperti kode sinkron.

Kode Pemahaman `for`

Contoh ini menggunakan pemahaman for untuk merangkai logika pengambilan ID pengguna dan detail pengguna yang sama seperti pada contoh flatMap. Perhatikan bahwa kodenya terlihat jauh lebih bersih!

import scala.concurrent.{Future, Await}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration._

object Main {
  def main(args: Array[String]): Unit = {
    def fetchUserId(): Future[Int] = Future {
      Thread.sleep(50)
      123
    }

    def fetchUserName(userId: Int): Future[String] = Future {
      Thread.sleep(100)
      s"Alice (ID: $userId)"
    }

    val userFuture: Future[String] = for {
      id <- fetchUserId()
      name <- fetchUserName(id)
    } yield name

    val result = Await.result(userFuture, 1.second)
    println(s"User name: $result")
  }
}

`zip`: Menggabungkan Hasil yang Tidak Saling Bergantung

Bagaimana jika Anda memiliki dua Future yang tidak saling bergantung dan ingin menggabungkan hasilnya setelah keduanya selesai? Metode zip sangat cocok untuk ini. Metode ini menerima Future lain dan mengembalikan Future baru yang berisi pasangan (sebuah Tuple) dari kedua hasil sukses tersebut.

Kedua Future berjalan secara bersamaan, dan zip menunggu hingga keduanya selesai.

import scala.concurrent.{Future, Await}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration._

object Main {
  def main(args: Array[String]): Unit = {
    val futureA = Future {
      Thread.sleep(100)
      "Hello"
    }

    val futureB = Future {
      Thread.sleep(50)
      "World"
    }

    val combinedFuture: Future[(String, String)] = futureA.zip(futureB)

    val (greeting, subject) = Await.result(combinedFuture, 1.second)
    println(s"$greeting $subject!")
  }
}

Pemeriksaan Singkat: Komposisi Future

Perhatikan potongan kode Scala berikut. Berapakah nilai akhir yang dicetak?

import scala.concurrent.{Future, Await}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration._

object Main {
  def main(args: Array[String]): Unit = {
    val f1 = Future { 5 }
    val f2 = f1.map(x => x + 2)
    val f3 = f2.flatMap(y => Future { y * 3 })

    val result = Await.result(f3, 1.second)
    println(result)
  }
}

Ringkasan: Merangkai Tugas Asinkron

Anda telah mempelajari cara-cara yang andal untuk menyusun Future Scala:

map: Mengubah hasil sukses sebuah Future menjadi nilai baru.
flatMap: Merangkai dua Future, dengan hasil yang pertama digunakan untuk memulai yang kedua.
Pemahaman for: Menyediakan sintaks yang bersih dan terlihat sinkron untuk rangkaian flatMap dan map.
zip: Menggabungkan hasil dari dua Future yang tidak saling bergantung menjadi sebuah tuple.

Alat-alat ini sangat penting untuk membangun aplikasi asinkron di Scala yang responsif dan efisien!

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Menggabungkan Operasi Asinkron” gratis?

Ya — teks lengkap “Menggabungkan Operasi Asinkron” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Scala for Backend Engineering & Functional Programming, upgrade ke CoddyKit PRO. Kursus Scala for Backend Engineering & Functional Programming mencakup 3 pelajaran total.

Apa yang akan aku pelajari di “Menggabungkan Operasi Asinkron”?

Pelajari cara merangkai dan menggabungkan beberapa `Future` menggunakan metode seperti `map`, `flatMap`, dan pemahaman `for`. Kamu berlatih Scala for Backend Engineering & Functional Programming dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Scala for Backend Engineering & Functional Programming?

Tidak diperlukan pengalaman sebelumnya. Scala for Backend Engineering & Functional Programming di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 3.

Berapa lama pelajaran “Menggabungkan Operasi Asinkron” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Scala for Backend Engineering & Functional Programming ini?

Ya. Setiap pelajaran Scala for Backend Engineering & Functional Programming menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Scala for Backend Engineering & Functional Programming