15

来自Programming in Scala (second edition)，第 98 页的底部：

Scala 程序员的平衡态度

更喜欢 val、不可变对象和没有副作用的方法。首先到达他们。当您有特定的需求和理由时，请使用具有副作用的变量、可变对象和方法。

前几页解释了为什么更喜欢 val、不可变对象和没有副作用的方法，所以这句话很有意义。

但是第二句话：“当你有特定的需要和理由时，使用 vars、可变对象和具有副作用的方法。” 解释得不是很好。

所以我的问题是：

使用具有副作用的变量、可变对象和方法的理由或具体需要是什么？

Ps：如果有人可以为每个例子提供一些例子（除了解释），那就太好了。

4

4 回答 4

16

在许多情况下，函数式编程提高了抽象级别，从而使您的代码更简洁，更容易/更快地编写和理解。但是在某些情况下，生成的字节码不能像命令式解决方案那样优化（快速）。

目前（Scala 2.9.1）一个很好的例子是总结范围：

(1 to 1000000).foldLeft(0)(_ + _)

相对：

var x = 1
var sum = 0
while (x <= 1000000) {
  sum += x
  x += 1
}

如果您分析这些，您会注意到执行速度的显着差异。所以有时表现是一个很好的理由。

于 2012-02-01T10:48:39.480 回答
8

易于小更新

使用可变性的一个原因是如果您正在跟踪一些正在进行的过程。例如，假设我正在编辑一个大型文档，并且有一组复杂的类来跟踪文本的各种元素、编辑历史、光标位置等。现在假设用户点击文本的不同部分。我是否重新创建文档对象，复制许多字段但不复制EditState字段；EditState用新的ViewBounds和重新创建documentCursorPosition？还是我在一个地方改变一个可变变量？ 只要线程安全不是问题，那么仅更新一个或两个变量就比复制所有内容要简单得多且不易出错。如果线程安全是一个问题，那么防止并发访问可能比使用不可变方法和处理过期请求更有效。

计算效率

使用可变性的另一个原因是速度。创建对象很便宜，但简单的方法调用更便宜，对原始类型的操作更便宜。

例如，假设我们有一张地图，我们想要对这些值和这些值的平方求和。

val xs = List.range(1,10000).map(x => x.toString -> x).toMap
val sum = xs.values.sum
val sumsq = xs.values.map(x => x*x).sum

如果你每隔一段时间就这样做，那没什么大不了的。但是，如果您注意正在发生的事情，对于每个列表元素，您首先重新创建它（值），然后对其求和（装箱），然后再次重新创建它（值），然后再次以平方形式重新创建它（地图） ，然后求和。这至少是六个对象创建和五个完整遍历，只是为了对每个项目进行两次加法和一次乘法。 令人难以置信的低效。

您可能会尝试通过使用折叠避免多次递归并仅通过地图一次来做得更好：

val (sum,sumsq) = ((0,0) /: xs){ case ((sum,sumsq),(_,v)) => (sum + v, sumsq + v*v) }

这要好得多，在我的机器上性能提高了大约 15 倍。但是每次迭代仍然创建三个对象。如果相反，你

case class SSq(var sum: Int = 0, var sumsq: Int = 0) {
  def +=(i: Int) { sum += i; sumsq += i*i }
}
val ssq = SSq()
xs.foreach(x => ssq += x._2)

你又快了两倍，因为你减少了拳击。如果您将数据保存在数组中并使用 while 循环，那么您可以避免所有对象创建和装箱，并将速度提高 20 倍。

现在，也就是说，您还可以为您的数组选择一个递归函数：

val ar = Array.range(0,10000)
def suma(xs: Array[Int], start: Int = 0, sum: Int = 0, sumsq: Int = 0): (Int,Int) = {
  if (start >= xs.length) (sum, sumsq)
  else suma(xs, start+1, sum+xs(start), sumsq + xs(start)*xs(start))
}

并以这种方式编写它与可变 SSq 一样快。但如果我们改为这样做：

def sumb(xs: Array[Int], start: Int = 0, ssq: (Int,Int) = (0,0)): (Int,Int) = {
  if (start >= xs.length) ssq
  else sumb(xs, start+1, (ssq._1+xs(start), ssq._2 + xs(start)*xs(start)))
}

我们现在又慢了 10 倍，因为我们必须在每一步中创建一个对象。

所以底线是，只有当您不能方便地将更新结构作为方法的独立参数携带时，您才具有不变性才重要。一旦你超越了它的复杂性，可变性可能是一个巨大的胜利。

累积对象创建

如果您需要使用来自潜在错误数据的字段构建复杂对象n，您可以使用如下所示的构建器模式：

abstract class Built {
  def x: Int
  def y: String
  def z: Boolean
}
private class Building extends Built {
  var x: Int = _
  var y: String = _
  var z: Boolean = _
}

def buildFromWhatever: Option[Built] = {
  val b = new Building
  b.x = something
  if (thereIsAProblem) return None
  b.y = somethingElse
  // check
  ...
  Some(b)
}

这仅适用于可变数据。当然，还有其他选择：

class Built(val x: Int = 0, val y: String = "", val z: Boolean = false) {}
def buildFromWhatever: Option[Built] = {
  val b0 = new Built
  val b1 = b0.copy(x = something)
  if (thereIsAProblem) return None
  ...
  Some(b)
}

这在许多方面甚至更干净，除了您必须为每次所做的更改复制一次对象，这可能会非常缓慢。而且这些都不是特别防弹的。为此，您可能想要

class Built(val x: Int, val y: String, val z: Boolean) {}
class Building(
  val x: Option[Int] = None, val y: Option[String] = None, val z: Option[Boolean] = None
) {
  def build: Option[Built] = for (x0 <- x; y0 <- y; z0 <- z) yield new Built(x,y,z)
}

def buildFromWhatever: Option[Build] = {
  val b0 = new Building
  val b1 = b0.copy(x = somethingIfNotProblem)
  ...
  bN.build
}

但同样，有很多开销。

于 2012-02-01T16:12:23.897 回答
5

我发现命令式/可变风格更适合动态编程算法。如果您坚持不变性，那么对于大多数人来说，编程会变得更加困难，并且您最终会使用大量内存和/或堆栈溢出。一个例子：函数范式中的动态编程

于 2012-02-01T15:14:45.700 回答
3

一些例子：

  1. （原为评论）任何程序都必须做一些输入和输出（否则没用）。但是根据定义，输入/输出是一种副作用，如果不调用具有副作用的方法就无法完成。

  2. Scala 的一大优势是能够使用 Java 库。其中许多依赖于具有副作用的可变对象和方法。

  3. 有时你需要一个var由于范围。请参阅此博客文章Temperature4中的示例。

  4. 并发编程。如果你使用actors，发送和接收消息是一个副作用；如果你使用线程，同步锁是一个副作用，锁是可变的；事件驱动的并发是关于副作用的；期货、并发集合等是可变的。

于 2012-02-01T12:36:15.597 回答