Scala for Backend Engineering & Functional Programming · Ders

Birleştirme

andThen ve compose

Birleştirme, CoddyKit'te ücretsiz bir Scala for Backend Engineering & Functional Programming dersidir. Bu, 4 dersinin 3. 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.

İşlevleri birleştirme

İşlev birleştirme, iki mevcut işlevi birbirine bağlayarak yeni bir işlev oluşturmaktır; böylece birinin çıktısı diğerinin girdisi olur. Scala bunun için andThen ve compose sağlar.

object Main {
  def main(args: Array[String]): Unit = {
    val addOne = (x: Int) => x + 1
    val double = (x: Int) => x * 2
    val both = addOne andThen double
    println(both(5))
  }
}

andThen: soldan sağa

f andThen g, önce f'yi, ardından g'yi çalıştırır. Soldan sağa okuma yürütme sırasıyla eşleşir; birçok kişi bunu sezgisel bulur.

(f andThen g)(x) == g(f(x))

object Main {
  def main(args: Array[String]): Unit = {
    val addOne = (x: Int) => x + 1
    val triple = (x: Int) => x * 3
    val pipeline = addOne andThen triple
    println(pipeline(4))  // (4 + 1) * 3
  }
}

compose: sağdan sola

f compose g, matematiksel sıra olan f(g(x)) biçiminde önce g'yi, ardından f'yi çalıştırır.

(f compose g)(x) == f(g(x))

object Main {
  def main(args: Array[String]): Unit = {
    val addOne = (x: Int) => x + 1
    val triple = (x: Int) => x * 3
    val pipeline = addOne compose triple
    println(pipeline(4))  // (4 * 3) + 1
  }
}

andThen ve compose karşılaştırması

İkisi birbirinin ayna görüntüsüdür:

f andThen g = g compose f
f compose g = g andThen f

Durumunuz için hangisi daha doğal okunuyorsa onu seçin.

object Main {
  def main(args: Array[String]): Unit = {
    val f = (x: Int) => x + 10
    val g = (x: Int) => x * 2
    println((f andThen g)(3))
    println((g compose f)(3))
  }
}

Birden çok işlevi zincirleme

Daha uzun ve yukarıdan aşağıya ilerleyen bir işlem hattı oluşturmak için birçok işlevi tekrarlanan andThen kullanımıyla zincirleyebilirsiniz.

object Main {
  def main(args: Array[String]): Unit = {
    val clean = (s: String) => s.trim
    val lower = (s: String) => s.toLowerCase
    val bang  = (s: String) => s + "!"
    val process = clean andThen lower andThen bang
    println(process("  HELLO  "))
  }
}

Birleştirme türleri değiştirir

Birleştirilen işlevlerin türleri uyumlu olmalıdır: ilkinin çıktı türü, ikincinin girdi türüyle eşleşmelidir. İşlem hattı boyunca türler değişebilir.

object Main {
  def main(args: Array[String]): Unit = {
    val length = (s: String) => s.length
    val isLong = (n: Int) => n > 5
    val check = length andThen isLong
    println(check("scala"))
    println(check("functional"))
  }
}

Birim işlev

identity, girdisini değiştirmeden döndürür. Bileşimin etkisiz elemanıdır: f andThen identity == f. Katlama işlemlerinde ve koşullu ifadelerde varsayılan değer olarak kullanışlıdır.

object Main {
  def main(args: Array[String]): Unit = {
    val f = (x: Int) => x * 2
    val same = f andThen identity[Int]
    println(same(7))
  }
}

reduce ile bileşim oluşturma

İşlevler değer olduğundan, birkaç işlevi bir listede saklayabilir ve hepsini andThen ile reduce kullanarak birleştirebilirsiniz.

object Main {
  def main(args: Array[String]): Unit = {
    val steps: List[Int => Int] = List(_ + 1, _ * 2, _ - 3)
    val pipeline = steps.reduce(_ andThen _)
    println(pipeline(5))  // ((5+1)*2)-3
  }
}

Yeniden kullanılabilir işlem hatları oluşturma

Bileşim, işlevsel programlamadaki temel fikirlerden biri olan, tek bir amaca hizmet eden küçük işlevleri daha büyük davranışlar oluşturacak şekilde bir araya getirmenizi teşvik eder.

object Main {
  def main(args: Array[String]): Unit = {
    val sanitize = (s: String) => s.trim.toLowerCase
    val capitalize = (s: String) => s.capitalize
    val format = sanitize andThen capitalize
    println(format("  aLiCe "))
  }
}

map ile bileşim

Bileşimle oluşturulmuş işlev de yalnızca bir işlevdir; bu nedenle tüm işlem hattını bir koleksiyon üzerinde uygulamak için doğrudan map'e aktarabilirsiniz.

object Main {
  def main(args: Array[String]): Unit = {
    val transform = ((x: Int) => x + 1) andThen ((x: Int) => x * x)
    println(List(1, 2, 3).map(transform))
  }
}

Bileşim sırasını dikkatle okuma

Yaygın bir hata, andThen ile compose'u karıştırmaktır. Şunu her zaman hatırlayın: andThen = önce bu, sonra şu; compose = tersi.

object Main {
  def main(args: Array[String]): Unit = {
    val inc = (x: Int) => x + 1
    val sqr = (x: Int) => x * x
    println((inc andThen sqr)(2))  // (2+1)^2 = 9
    println((inc compose sqr)(2))  // (2^2)+1 = 5
  }
}

Hızlı kontrol

f ve g verildiğinde (f andThen g)(x) neyi hesaplar?

Özet

İşlev bileşimini öğrendiniz:

f andThen g → g(f(x)) (soldan sağa)
f compose g → f(g(x)) (sağdan sola)
Bunlar birbirinin ayna görüntüsüdür
identity etkisiz elemandır
İşlev listelerini reduce(_ andThen _) ile birleştirebilirsiniz

Sıkça Sorulan Sorular

“Birleştirme” dersi ücretsiz mi?

Evet — “Birleştirme” 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.

“Birleştirme” dersinde ne öğreneceğim?

andThen ve compose 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 3. dersidir.

“Birleştirme” 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