缩小、折叠或扫描（左/右）？

我应该什么时候使用reduceLeft, reduceRight, foldLeft, foldRight, scanLeft or scanRight?

我想要对它们的差异有一个直观/概述 - 可能有一些简单的例子。

一般来说，所有 6 个折叠函数都对集合的每个元素应用二元运算符。每个步骤的结果都会传递到下一步（作为二元运算符的两个参数之一的输入）。这样我们就可以cumulate一个结果。

reduceLeft and reduceRight累积单个结果。

foldLeft and foldRight使用起始值累积单个结果。

scanLeft and scanRight使用起始值累积中间累积结果的集合。

积累

从左往前...

带有元素的集合abc和一个二元运算符add我们可以探索从集合的 LEFT 元素（从 A 到 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

从右和向后...

如果我们从 RIGHT 元素开始并向后移动（从 C 到 A），我们会注意到现在second二元运算符的参数累加结果（运算符是相同的，我们只是交换了参数名称以明确它们的角色）：

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)

.

去累积

从左往前...

如果我们要去累积从集合的左侧元素开始减去一些结果，我们将通过第一个参数累积结果res我们的二元运算符minus:

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)

从右和向后...

但现在请留意 xRight 的变体！请记住，xRight 变量中的（去）累积值被传递给second范围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) 

最后一个 List(-2, 3, -1, 4, 0) 可能不是您直观所期望的！

如您所见，您可以通过简单地运行 scanX 来检查 FoldX 正在做什么，并调试每个步骤的累积结果。

底线

• 累积结果reduceLeft or reduceRight.
• 累积结果foldLeft or foldRight如果你有一个起始值。

• 累积中间结果的集合scanLeft or scanRight.

• 如果您想走，请使用 xLeft 变体forwards通过收集。

• 如果您想继续，请使用 xRight 变体向后通过收集。