Ne zaman**, reduceRight, , *, *foldLeft*7 4 8* veya scanRight kullanmalıyım?

Belki bazı basit örnekler ile farklılıklarının sezgi/bir bakış istiyorum.

Genel olarak, tüm 6 kat fonksiyonları bir koleksiyonun her elemanı için bir ikili işleç uygulamak. Her adım sonucu bir sonraki adım (ikili operatör iki değişkeni giriş olarak) geçer. Bu edebilirizbiriktiğindesonuç.

reduceLeft reduceRight tek bir sonuç biriktiğinde.

foldLeft foldRight tek bir sonuç, bir başlangıç değeri kullanarak biriktiğinde.

scanLeft scanRight Ara toplu sonuçlar başlangıç değeri kullanarak bir koleksiyon biriktiğinde.

Birikir

SOLDAN ileri bir geri...

Bir koleksiyonun elemanları abc ve bir ikili operatör add biz keşfetmek ne farklı kat fonksiyonları ne zaman gittiğini ileri SOL öğesi koleksiyonu (C):

val abc = List("A", "B", "C")

def add(res: String, x: String) = { 
  println(s"op: $res   $x = ${res   x}")
  res   x
}

abc.reduceLeft(add)
// op: A   B = AB
// op: AB   C = ABC    // accumulates value AB in *first* operator arg `res`
// res: String = ABC

abc.foldLeft("z")(add) // with start value "z"
// op: z   A = zA      // initial extra operation
// op: zA   B = zAB
// op: zAB   C = zABC
// res: String = zABC

abc.scanLeft("z")(add)
// op: z   A = zA      // same operations as foldLeft above...
// op: zA   B = zAB
// op: zAB   C = zABC
// res: List[String] = List(z, zA, zAB, zABC) // maps intermediate results

SAĞA ve geriye doğru...

DOĞRU öğe ile başlar ve geriye doğru (C) eğer bunu şimdi fark ederizikincisonuç (operatör aynıdır, sadece değişken isimleri rolleri açık anahtarlı) birikir ikili kullanıcısı ile bağımsız değişken:

def add(x: String, res: String) = {
  println(s"op: $x   $res = ${x   res}")
  x   res
}

abc.reduceRight(add)
// op: B   C = BC
// op: A   BC = ABC  // accumulates value BC in *second* operator arg `res`
// res: String = ABC

abc.foldRight("z")(add)
// op: C   z = Cz
// op: B   Cz = BCz
// op: A   BCz = ABCz
// res: String = ABCz

abc.scanRight("z")(add)
// op: C   z = Cz
// op: B   Cz = BCz
// op: A   BCz = ABCz
// res: List[String] = List(ABCz, BCz, Cz, z)

.

De-biriktiğinde

SOLDAN ileri bir geri...

Olursak yerinede-biriktiğindebir çıkarma toplama SOL öğeden başlayarak bazı sonucu, ilk bağımsız değişken ile sonuç biriktiğinde biz ikili görevlimiz minus res:

val xs = List(1, 2, 3, 4)

def minus(res: Int, x: Int) = {
  println(s"op: $res - $x = ${res - x}")
  res - x
}

xs.reduceLeft(minus)
// op: 1 - 2 = -1
// op: -1 - 3 = -4  // de-cumulates value -1 in *first* operator arg `res`
// op: -4 - 4 = -8
// res: Int = -8

xs.foldLeft(0)(minus)
// op: 0 - 1 = -1
// op: -1 - 2 = -3
// op: -3 - 3 = -6
// op: -6 - 4 = -10
// res: Int = -10

xs.scanLeft(0)(minus)
// op: 0 - 1 = -1
// op: -1 - 2 = -3
// op: -3 - 3 = -6
// op: -6 - 4 = -10
// res: List[Int] = List(0, -1, -3, -6, -10)

SAĞA ve geriye doğru...

Ama xRight varyasyonları için dışarı bak! XRight varyasyonları (de-)toplam değer geçirilir unutmayınikinciparametre ikili görevlimiz res minus:

def minus(x: Int, res: Int) = {
  println(s"op: $x - $res = ${x - res}")
  x - res
}

xs.reduceRight(minus)
// op: 3 - 4 = -1
// op: 2 - -1 = 3  // de-cumulates value -1 in *second* operator arg `res`
// op: 1 - 3 = -2
// res: Int = -2

xs.foldRight(0)(minus)
// op: 4 - 0 = 4
// op: 3 - 4 = -1
// op: 2 - -1 = 3
// op: 1 - 3 = -2
// res: Int = -2

xs.scanRight(0)(minus)
// op: 4 - 0 = 4
// op: 3 - 4 = -1
// op: 2 - -1 = 3
// op: 1 - 3 = -2
// res: List[Int] = List(-2, 3, -1, 4, 0) 

Son Liste(-2, , -1 3, 4, 0) sezgisel olarak ne beklediğiniz belki de değildir!

Gördüğünüz gibi, foldX ne yaptığını sadece bir scanX çalıştırarak yerine kontrol edin ve her adımda format sonucu hata.

Alt satırda

• reduceLeft reduceRight ile sonuç biriktiğinde.
• Eğer başlangıç değeri varsa foldLeft foldRight ile sonuç biriktiğinde.

• scanLeft scanRight Ara sonuçları bir koleksiyon biriktiğinde.

• Eğer gitmek istiyorsan xLeft bir varyasyon kullanıniletirtopluluk içinde.

• Eğer gitmek istiyorsan xRight bir varyasyon kullanıngeriye doğrutopluluk içinde.