Scala for Backend Engineering & Functional Programming · Ders

reduce ve aggregate

Öğeleri birleştirmenin diğer yolları.

reduce ve aggregate, 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.

Fold'dan reduce'a

Bazen ayrı bir başlangıç değeri vermeden öğeleri birleştirmek istersiniz.

reduce ilk öğeyi başlangıç birikim değeri olarak kullanır ve kalan öğeleri bununla birleştirir.

Öğe türü ile sonuç türünün aynı olduğu durumlarda fold işleminin daha yalın bir benzeridir.

reduce Temelleri

reduce, açık bir başlangıç değeri olmadan ikili bir işlevi (a, b) alır ve koleksiyona uygular.

Toplama işleminde tüm öğeleri basitçe birbirine ekler.

val xs = List(1, 2, 3, 4)
val total = xs.reduce((a, b) => a + b)

@main def run(): Unit =
  println(total)  // 10

Boş Koleksiyon Tuzağı

reduce bir başlangıç değerine sahip olmadığından boş bir koleksiyon üzerinde çağrılması UnsupportedOperationException fırlatır.

fold ve foldLeft, sağlanan başlangıç değerine başvurdukları için boş koleksiyonlarda güvenlidir.

reduce işlemini yalnızca koleksiyonun boş olmadığını bildiğinizde kullanın.

// List.empty[Int].reduce(_ + _)
// throws UnsupportedOperationException

List.empty[Int].foldLeft(0)(_ + _)  // safe, returns 0

Güvenli Kullanım için reduceOption

reduceOption bir Option döndürür; boş bir koleksiyon için hata fırlatmak yerine None verir.

Boş olma ihtimali varsa azaltma işlemi yapmanın güvenli yolu budur.

val xs = List(5, 9, 2)
val maybeMax = xs.reduceOption(_ max _)

@main def run(): Unit =
  println(maybeMax)  // Some(9)

reduceLeft ve reduceRight

fold gibi, reduce işleminin de yönlü çeşitleri vardır.

reduceLeft soldan sağa, reduceRight ise sağdan sola birleştirir. Sade reduce, paralel koleksiyonlarda sıralama garantisi vermez; bu nedenle yön önemli olduğunda açıkça belirtilen çeşidi kullanın.

val xs = List(1, 2, 3)
val l = xs.reduceLeft(_ - _)   // (1-2)-3 = -4
val r = xs.reduceRight(_ - _)  // 1-(2-3) = 2

@main def run(): Unit =
  println((l, r))  // (-4, 2)

aggregate Neden Var

fold ve reduce, biriktirici ile öğe türlerinin basitçe ilişkili olmasını gerektirir.

aggregate en genel fold işlemidir: biriktiricinin farklı bir tür olmasına izin verir VE Scala'ya kısmi biriktiricileri nasıl birleştireceğini söyler; bu, paralel işleme için önemlidir.

aggregate İmzası

aggregate; bir başlangıç değeri, bir öğeyi biriktiriciye ekleyen seqop ve iki biriktiriciyi birleştiren combop alır.

Sıralı bir koleksiyonda combop nadiren kullanılır; paralel bir koleksiyonda ise her parçanın sonuçlarını birleştirir.

val xs = List(1, 2, 3, 4)
val sum = xs.aggregate(0)(
  (acc, x) => acc + x,   // seqop
  (a, b)   => a + b      // combop
)

@main def run(): Unit = println(sum)  // 10

Farklı Türle aggregate

Burada aggregate, bir sözcük listesini tek bir Int uzunluk toplamında birleştirir.

seqop her sözcüğün uzunluğunu eklerken combop iki kısmi toplamı bir araya getirir.

Biriktirici türü (Int), öğe türünden (String) farklıdır.

val words = List("hi", "there", "you")
val chars = words.aggregate(0)(
  (acc, w) => acc + w.length,
  (a, b)   => a + b
)

@main def run(): Unit = println(chars)  // 10

Paralel Birleştirme

aggregate işleminin asıl gücü, paralel koleksiyonlarla kullanıldığında ortaya çıkar.

Her iş parçacığı kendi parçasını seqop ile birleştirir, ardından parçalar combop ile birleştirilir. Bu iki işlev, Scala'nın işi güvenli bir şekilde bölüp yeniden birleştirmesini sağlar.

// Conceptual: par splits the work
// val n = data.par.aggregate(0)(_ + _.length, _ + _)
// seqop runs per chunk, combop merges chunk results

Doğru Aracı Seçme

Sonuç türü öğe türüyle aynı olduğunda ve birleştirme birleşmeli olduğunda reduce veya reduceOption kullanın.

Sıralı olarak çalışırken bir başlangıç değerine veya farklı bir sonuç türüne ihtiyacınız varsa foldLeft kullanın.

Biriktirici ve öğe türleri farklı olduğunda ve paralel birleştirmeye uygun bir çözüm istediğinizde aggregate kullanın.

// reduce:    same type, non-empty, associative
// foldLeft:  seed + different type, sequential
// aggregate: different type + parallel merge

Tek Geçişte Birleştirme

aggregate, bir demet içinde biriktirme yaparak aynı anda birkaç şeyi hesaplayabilir.

Burada tek geçişte hem toplamı hem de sayıyı elde ediyor, demetleri combop içinde birleştiriyoruz.

val xs = List(2, 4, 6, 8)
val (s, c) = xs.aggregate((0, 0))(
  (acc, x) => (acc._1 + x, acc._2 + 1),
  (a, b)   => (a._1 + b._1, a._2 + b._2)
)

@main def run(): Unit = println((s, c))  // (20, 4)

Hızlı Kontrol

Boş olabilecek bir liste için hangi işlemin en güvenli olduğuna karar verin.

Özet

reduce, başlangıç değeri olmadan öğeleri birleştirir ve başlangıç olarak ilk öğeyi kullanır; boş bir koleksiyonda hata fırlatırken reduceOption bunun yerine None döndürür.

aggregate en genel fold işlemidir: bir başlangıç değeri, öğeleri birleştirmek için bir seqop ve paralel çalışma için kısmi biriktiricileri birleştiren bir combop alır.

Aynı türde birleşmeli birleştirme için reduce, sıralı ve başlangıç değerli fold işlemleri için foldLeft, türler farklı olduğunda veya paralel çalışacağınızda aggregate seçin.

Sıkça Sorulan Sorular

“reduce ve aggregate” dersi ücretsiz mi?

Evet — “reduce ve aggregate” 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.

“reduce ve aggregate” dersinde ne öğreneceğim?

Öğeleri birleştirmenin diğer yolları. 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.

“reduce ve aggregate” 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