PricingLoginStart free
Scala for Backend Engineering & Functional Programming · Ders

for-comprehension'larda Option

Option'ları zincirleyin

4. ders / 413 adım

for-comprehension'larda Option, 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.

Option'ları Temiz Bir Şekilde Zincirleme

Birden fazla flatMap ve map çağrısını zincirlemek okunması zor bir yapı oluşturabilir. Scala'nın for-anlamlandırması, aynı işlem için daha temiz bir söz dizimi sunar.

Bu, derleyicinin flatMap ve map çağrılarına yeniden yazdığı bir söz dizimi kolaylığıdır.

Temel for-anlamlandırması

for { ... } yield ... içinde her x <- option, değer mevcutsa onu çıkarır. yield son sonucu oluşturur.

Her Option bir Some ise sonuçtan bir Some elde edersiniz.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(3)
    val b: Option[Int] = Some(4)
    val sum = for {
      x <- a
      y <- b
    } yield x + y
    println(sum)
  }
}

None Üzerinde Kısa Devre

Herhangi bir üretici None ise tüm anlamlandırma None üretir. Kalan adımlar atlanır.

Bu, flatMap'in sağladığı kısa devre davranışının aynısıdır; ancak okunması daha kolaydır.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(3)
    val b: Option[Int] = None
    val sum = for {
      x <- a
      y <- b
    } yield x + y
    println(sum)
  }
}

Nasıl Sadeleştirildiği

Derleyici, bir for-anlamlandırmasını flatMap ve map işlemlerine yeniden yazar. Bu iki kod parçası eşdeğerdir.

Bunu anlamak, sonuç türünü öngörmenize yardımcı olur.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(3)
    val b: Option[Int] = Some(4)
    val viaFor = for { x <- a; y <- b } yield x + y
    val viaFlatMap = a.flatMap(x => b.map(y => x + y))
    println(viaFor)
    println(viaFlatMap)
  }
}

Önceki Değerleri Kullanma

Daha sonraki üreticiler, daha önce bağlanmış değerlere başvurabilir. Böylece her adımın bir önceki adıma bağlı olması sağlanır.

object Main {
  def main(args: Array[String]): Unit = {
    val base: Option[Int] = Some(10)
    val result = for {
      x <- base
      y <- Some(x * 2)
    } yield x + y
    println(result)
  }
}

Ara Değer Bağlamaları

= kullanarak for-anlamlandırması içinde sıradan değerler tanımlayabilirsiniz (ok işareti kullanmadan). Bu, ara hesaplamalar için kullanışlıdır.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(6)
    val result = for {
      x <- a
      doubled = x * 2
    } yield doubled + 1
    println(result)
  }
}

if ile Koşul Denetimleri

Bir anlamlandırma, if filtresi içerebilir. Koşul sağlanmazsa sonuç None olur.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(8)
    val even = for {
      x <- a
      if x % 2 == 0
    } yield x
    println(even)
    val b: Option[Int] = Some(7)
    println(for { x <- b if x % 2 == 0 } yield x)
  }
}

Aramaları Birleştirme

Tipik bir kullanım: birden fazla anahtarı arayın ve bunları yalnızca tümü mevcutsa birleştirin.

object Main {
  val data = Map("a" -> 1, "b" -> 2)
  def main(args: Array[String]): Unit = {
    val combined = for {
      x <- data.get("a")
      y <- data.get("b")
    } yield x + y
    println(combined)
    val missing = for {
      x <- data.get("a")
      z <- data.get("c")
    } yield x + z
    println(missing)
  }
}

for-anlamlandırmaları neden kullanılır?

Şunları sağlarlar:

  • Bağımlı Option'ların okunabilir bir sırayla işlenmesi
  • None üzerinde otomatik kısa devre
  • flatMap/map ile aynı güç, ancak daha düz bir yapı
  • if ile filtreleme ve ara = bağlamaları

Bir Değere Ulaşma

Anlamlandırma bir Option ürettiğinden, sıradan bir değer elde etmek için işlemi getOrElse veya fold ile tamamlayın.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(3)
    val b: Option[Int] = Some(4)
    val total = (for { x <- a; y <- b } yield x + y).getOrElse(0)
    println(total)
  }
}

Hepsini Bir Araya Getirme

Tam işlem hattı: iki girdiyi ayrıştırın, bir koşulu denetleyin, birleştirin ve varsayılan bir değer sağlayın.

object Main {
  def parse(s: String): Option[Int] = s.toIntOption
  def main(args: Array[String]): Unit = {
    val result = for {
      x <- parse("10")
      y <- parse("5")
      if y != 0
    } yield x / y
    println(result.getOrElse(-1))
  }
}

Kısa Kontrol

Option üzerinde for-anlamlandırmalarını anlama düzeyinizi test edin.

İnteraktif derste cevapla

Özet

Option'ları for-anlamlandırmalarıyla zincirlemeyi öğrendiniz:

  • for { x <- a; y <- b } yield ..., Option'ları okunabilir bir şekilde sıralar
  • Bu yapı flatMap/map işlemlerine sadeleştirilir
  • Herhangi bir None, tüm sonucu kısa devreyle None yapar
  • Daha sonraki üreticiler önceki değerleri kullanabilir; = bağlama ekler, if filtreler
  • Sıradan bir değer elde etmek için işlemi getOrElse veya fold ile tamamlayın
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şlaTüm kursu görüntüle

Sıkça Sorulan Sorular

“for-comprehension'larda Option” dersi ücretsiz mi?

Evet — “for-comprehension'larda Option” 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.

“for-comprehension'larda Option” dersinde ne öğreneceğim?

Option'ları zincirleyin 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.

“for-comprehension'larda Option” 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

  1. null'dan Kaçınma
  2. Option üzerinde map ve flatMap
  3. getOrElse ve fold
  4. for-comprehension'larda Option
← Scala for Backend Engineering & Functional Programming Sayfasına Dön