Scala for Backend Engineering & Functional Programming · Ders

for Yapısını Açma

map ve flatMap

1. ders / 413 adım

for Yapısını Açma, CoddyKit'te ücretsiz bir Scala for Backend Engineering & Functional Programming dersidir. Bu, 4 dersinin 1. 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.

For-anlamlandırması nedir?

Scala'da for-anlamlandırması, koleksiyonlarla ve diğer kapsayıcı türlerle çalışmak için kullanılan özel bir söz dizimidir. Buyurgan bir döngüye benzer; ancak aslında derleyicinin map, flatMap, filter ve foreach çağrılarına yeniden yazdığı bir söz dizimi kolaylığıdır.

Sadeleştirme işlemini anlamak, özel türler üzerindeki anlamlandırmalar da dâhil olmak üzere her for-anlamlandırması hakkında akıl yürütmenize yardımcı olur.

object Main {
  def main(args: Array[String]): Unit = {
    val result = for (x <- List(1, 2, 3)) yield x * 10
    println(result)
  }
}

Tek bir üretici map işlemine dönüşür

Bir for-anlamlandırması tam olarak tek bir üretici içeriyor ve yield kullanıyorsa, derleyici bunu tek bir map çağrısına dönüştürür.

for (x <- xs) yield f(x)
şuna dönüşür: xs.map(x => f(x))

object Main {
  def main(args: Array[String]): Unit = {
    val a = for (x <- List(1, 2, 3)) yield x + 1
    val b = List(1, 2, 3).map(x => x + 1)
    println(a == b)
  }
}

yield anahtar sözcüğü

yield anahtar sözcüğü, Scala'ya sonuçları aynı türden yeni bir koleksiyonda toplamasını söyler.

yield olmadan for-anlamlandırması, her öğe için bir yan etki gerçekleştirir ve Unit döndürür (foreach işlemine dönüşür).

object Main {
  def main(args: Array[String]): Unit = {
    // No yield: side effect only
    for (x <- List("a", "b")) println(x)
    // With yield: builds a new List
    val upper = for (x <- List("a", "b")) yield x.toUpperCase
    println(upper)
  }
}

İki üretici flatMap + map işlemine dönüşür

İki veya daha fazla üretici olduğunda dış üreticiler flatMap işlemine, en içteki üretici ise map işlemine dönüşür.

for (x <- xs; y <- ys) yield f(x, y)
şuna dönüşür: xs.flatMap(x => ys.map(y => f(x, y)))

object Main {
  def main(args: Array[String]): Unit = {
    val pairs = for {
      x <- List(1, 2)
      y <- List("a", "b")
    } yield (x, y)
    println(pairs)
  }
}

Eşdeğer flatMap İşlemini Görme

Burada aynı mantığı iki şekilde yazıyoruz. Eşdeğer olduklarını göstermek, for-anlamlandırmalarının sihirli bir özellik eklemediğini, yalnızca okunabilirlik sağladığını kanıtlar.

object Main {
  def main(args: Array[String]): Unit = {
    val sugar = for {
      x <- List(1, 2)
      y <- List(10, 20)
    } yield x + y

    val desugared = List(1, 2).flatMap(x => List(10, 20).map(y => x + y))

    println(sugar)
    println(sugar == desugared)
  }
}

Dış üretici için flatMap neden kullanılır?

Her dış öğe, iç sonuçlardan oluşan tam bir koleksiyon üretir. Dış üretici için map kullansaydık List(List(...), List(...)) gibi iç içe bir koleksiyon elde ederdik.

flatMap, bu iç içe listeleri tek bir düz sonuçta birleştirir.

object Main {
  def main(args: Array[String]): Unit = {
    val nested = List(1, 2).map(x => List(10, 20).map(y => x + y))
    val flat   = List(1, 2).flatMap(x => List(10, 20).map(y => x + y))
    println(nested)
    println(flat)
  }
}

yield olmadan for, foreach işlemidir

yield içermeyen bir for döngüsü foreach işlemine yeniden yazılır. Gövdeyi yan etkileri için çalıştırır ve Unit üretir.

for (x <- xs) doSomething(x)
şuna dönüşür: xs.foreach(x => doSomething(x))

object Main {
  def main(args: Array[String]): Unit = {
    val r: Unit = for (x <- List(1, 2, 3)) print(x + " ")
    println()
    println("Return type is Unit")
  }
}

Sonuç türü ilk üreticiyi izler

Sonucun türü, ilk üreticinin koleksiyonu tarafından belirlenir. Bir List üzerindeki for bir List, bir Set üzerindeki for bir Set, bir Option üzerindeki for ise bir Option üretir.

object Main {
  def main(args: Array[String]): Unit = {
    val fromList = for (x <- List(1, 2, 2, 3)) yield x
    val fromSet  = for (x <- Set(1, 2, 2, 3)) yield x
    println(fromList)
    println(fromSet)
  }
}

Değerleri = ile Bağlama

Bir for-anlamlandırması içinde ara değerleri = ile bağlayabilirsiniz. Bu, aynı hesaplamanın yeniden yapılmasını önler ve okunabilirliği artırır.

Bu yapı, fazladan değeri bir demet içinde taşıyan bir map işlemine sadeleştirilir.

object Main {
  def main(args: Array[String]): Unit = {
    val result = for {
      x <- List(1, 2, 3)
      doubled = x * 2
    } yield doubled + 1
    println(result)
  }
}

map/flatMap içeren her türde çalışır

Sadeleştirme yalnızca map ve flatMap işlemlerine dayandığından, for-anlamlandırmaları bu yöntemleri tanımlayan her türde çalışır: Option, Either, Try, Future ve kendi sınıflarınız.

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

Asıl kazanç okunabilirliktir

Derin biçimde iç içe geçmiş bir flatMap/map zincirini temiz bir for-anlamlandırmasıyla karşılaştırın. Aynı şeye derlenirler; ancak for sürümü, bir tarif gibi yukarıdan aşağıya okunur.

object Main {
  def main(args: Array[String]): Unit = {
    val chained = List(1, 2).flatMap(a => List(3, 4).map(b => a * b))
    val readable = for {
      a <- List(1, 2)
      b <- List(3, 4)
    } yield a * b
    println(chained == readable)
  }
}

Kısa Kontrol

Derleyici, iki üretici ve bir yield içeren for-anlamlandırmasını nasıl sadeleştirir?

İnteraktif derste cevapla

Özet

For-anlamlandırmalarının nasıl sadeleştirildiğini öğrendiniz:

Tek üretici + yield → map
Birden çok üretici + yield → flatMap (dış) + map (iç)
yield yok → Unit döndüren foreach
val = bağlamaları ara değerler ekler
Sonuç türü ilk üreticiyi izler

map ve flatMap içeren her tür, for-anlamlandırmasında kullanılabilir.

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

“for Yapısını Açma” dersi ücretsiz mi?

Evet — “for Yapısını Açma” 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 Yapısını Açma” dersinde ne öğreneceğim?

map ve flatMap 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 1. dersidir.

“for Yapısını Açma” 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