Scala for Backend Engineering & Functional Programming · Ders

Option ve Future ile Kullanım

Monadik zincirleme

4. ders / 413 adım

Option ve Future ile Kullanım, CoddyKit'te ücretsiz bir Scala for Backend Engineering & Functional Programming dersidir. Bu, 4 dersinin 4. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Scala for Backend Engineering & Functional Programming öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Scala for Backend Engineering & Functional Programming kursu toplamda 4 dersten oluşur.

Koleksiyonların ötesinde

For-comprehension'lar yalnızca listelerle sınırlı değildir. map ve flatMap sağlayan her tür kullanılabilir; bunlara Option, Either, Try ve Future dahildir. Buna monadik zincirleme denir.

object Main {
  def main(args: Array[String]): Unit = {
    val sum = for {
      a <- Some(10)
      b <- Some(20)
    } yield a + b
    println(sum)
  }
}

Option, None durumunda kısa devre yapar

Option ile for-comprehension yalnızca her üretici Some olduğunda sonuç üretir. Herhangi biri None olursa tüm sonuç None olur ve sonraki adımlar atlanır.

object Main {
  def main(args: Array[String]): Unit = {
    val ok = for {
      a <- Some(2)
      b <- Some(3)
    } yield a * b

    val missing = for {
      a <- Some(2)
      b <- None: Option[Int]
    } yield a * b

    println(ok)
    println(missing)
  }
}

İsteğe bağlı aramaları zincirleme

Yaygın bir örüntü, anahtarları bir Map içinde aramaktır; her arama bir Option döndürür. For-comprehension, yalnızca tüm aramalar başarılı olursa bir değer üretir.

object Main {
  def main(args: Array[String]): Unit = {
    val prices = Map("apple" -> 3, "bread" -> 5)
    val total = for {
      a <- prices.get("apple")
      b <- prices.get("bread")
    } yield a + b
    println(total)

    val missing = for {
      a <- prices.get("apple")
      c <- prices.get("milk")
    } yield a + c
    println(missing)
  }
}

Bu neden iç içe if-else yapısından daha iyi

For-comprehension olmadan, iç içe desen eşleştirmeleri veya null kontrolleri kullanmanız gerekirdi. Monadik biçim, bu piramidi temiz ve doğrusal bir diziye dönüştürür.

object Main {
  def parse(s: String): Option[Int] = s.toIntOption
  def main(args: Array[String]): Unit = {
    val result = for {
      x <- parse("40")
      y <- parse("2")
    } yield x + y
    println(result)
  }
}

Guard'lar Option ile de çalışır

Bir Option for-comprehension'ının içindeki guard, koşul başarısız olduğunda değeri None'a dönüştürür ve satır içi doğrulama görevi görür.

object Main {
  def main(args: Array[String]): Unit = {
    def validate(age: Int): Option[Int] =
      for {
        a <- Some(age)
        if a >= 18
      } yield a
    println(validate(25))
    println(validate(15))
  }
}

Future'a giriş

Bir Future, daha sonra kullanılabilir olacak bir değeri temsil eder. Option gibi map ve flatMap yöntemlerine sahiptir; bu nedenle for-comprehension'lar eşzamansız adımları sıralı hâle getirir.

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Await
import scala.concurrent.duration._

object Main {
  def main(args: Array[String]): Unit = {
    val f = for {
      a <- Future(10)
      b <- Future(20)
    } yield a + b
    println(Await.result(f, 2.seconds))
  }
}

Future'lar burada sıralı çalışır

Bir for-comprehension içinde bir üretici diğerine bağlı olduğunda, her flatMap önceki sonucu beklediği için Future'lar sıralı olarak çalışır.

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Await
import scala.concurrent.duration._

object Main {
  def main(args: Array[String]): Unit = {
    val f = for {
      a <- Future(5)
      b <- Future(a * 2)
    } yield a + b
    println(Await.result(f, 2.seconds))
  }
}

Future'ları paralel çalıştırma

Future'ları paralel çalıştırmak için onları for-comprehension'dan önce başlatıp ardından birleştirin. Bağımsız işler birbirini beklemek yerine eş zamanlı ilerler.

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Await
import scala.concurrent.duration._

object Main {
  def main(args: Array[String]): Unit = {
    val fa = Future(100)
    val fb = Future(200)
    val combined = for {
      a <- fa
      b <- fb
    } yield a + b
    println(Await.result(combined, 2.seconds))
  }
}

Daha zengin hatalar için Either

Either[E, A], başarısızlık durumunda bir hata değeri taşır. For-comprehension içinde ilk Left kısa devre yapar ve döndürülür.

object Main {
  def parse(s: String): Either[String, Int] =
    s.toIntOption.toRight(s"not a number: $s")
  def main(args: Array[String]): Unit = {
    val good = for { a <- parse("3"); b <- parse("4") } yield a + b
    val bad  = for { a <- parse("3"); b <- parse("x") } yield a + b
    println(good)
    println(bad)
  }
}

Aynı biçim, birçok tür

Option, Either, Try veya Future kullansanız da for-comprehension'ın aynı göründüğüne dikkat edin. Yalnızca başarısızlık davranışları farklıdır. Monadik zincirlemenin gücü bu tekdüzelikten gelir.

import scala.util.Try

object Main {
  def main(args: Array[String]): Unit = {
    val result = for {
      a <- Try("21".toInt)
      b <- Try("2".toInt)
    } yield a * b
    println(result)
  }
}

Türleri karıştırmaya izin verilmez

Tek bir for-comprehension içindeki tüm üreticiler aynı monad olmalıdır. Bir Option üreticisini bir Future üreticisiyle doğrudan karıştıramazsınız; önce birini dönüştürün (örneğin Future.fromTry kullanın veya Option'ı sarın).

object Main {
  def main(args: Array[String]): Unit = {
    // Convert the Option to keep types consistent
    val maybe: Option[Int] = Some(7)
    val result = for {
      a <- maybe
      b <- maybe.map(_ + 1)
    } yield a + b
    println(result)
  }
}

Kısa Kontrol

Bir Option for-comprehension'ında üreticilerden biri None üretirse ne olur?

İnteraktif derste cevapla

Özet

For-comprehension'larla monadik zincirlemeyi öğrendiniz:

map ve flatMap yöntemlerine sahip her türle çalışır
Option, None durumunda kısa devre yapar
Either ve Try, hata bilgisi taşıyarak başarısızlık durumunda kısa devre yapar
Future, eşzamansız adımları sıralı hâle getirir; paralellik için onları erkenden başlatın
Tüm üreticiler aynı monad türünü paylaşmalıdır

Başlamak ücretsiz

Yapay zeka eğitmeniyle Scala öğren — ücretsiz

Tarayıcında gerçek kod yaz ve çalıştır, 7/24 yapay zeka eğitmeninden anında yardım al; web'de ya da uygulamada kaldığın yerden devam et.

Kurslar: 39
Dersler: 143

Ücretsiz öğrenmeye başla Tüm kursu görüntüle

Sıkça Sorulan Sorular

“Option ve Future ile Kullanım” dersi ücretsiz mi?

Evet — “Option ve Future ile Kullanım” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Scala for Backend Engineering & Functional Programming kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Scala for Backend Engineering & Functional Programming kursu toplamda 4 dersten oluşur.

“Option ve Future ile Kullanım” dersinde ne öğreneceğim?

Monadik zincirleme Scala for Backend Engineering & Functional Programming ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Scala for Backend Engineering & Functional Programming öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Scala for Backend Engineering & Functional Programming, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 4. dersidir.

“Option ve Future ile Kullanım” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Scala for Backend Engineering & Functional Programming dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Scala for Backend Engineering & Functional Programming dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← Scala for Backend Engineering & Functional Programming Sayfasına Dön