2

val 和 var 在 scala 中,我认为这个概念是可以理解的。

我想做这样的事情(类似java):

trait PersonInfo {
  var name: Option[String] = None
  var address: Option[String] = None
  // plus another 30 var, for example 
 }
case class Person() extends PersonInfo
object TestObject {
  def main(args: Array[String]): Unit = {
         val p = new Person()
         p.name = Some("someName")
         p.address = Some("someAddress")
  }
}

所以我可以更改姓名,地址等...

这工作得很好,但问题是,在我的程序中,我最终将所有内容都作为 vars。据我了解 val 在scala中是“首选”。val 如何在这种类型的示例中工作,而不必在每次更改其中一个参数时都重写所有 30 多个参数?

也就是说,我可以

trait PersonInfo {
  val name: Option[String] 
  val address: Option[String] 
  // plus another 30 val, for example 
 }
case class Person(name: Option[String]=None, address: Option[String]=None, ...plus another 30.. ) extends PersonInfo
object TestObject {
  def main(args: Array[String]): Unit = {
         val p = new Person("someName", "someAddress", .....)
         // and if I want to change one thing, the address for example
         val p2 = new Person("someName", "someOtherAddress", .....)
  }
}

这是“正常”的 scala 做事方式(不受 22 个参数限制)吗?可以看出,我对这一切都很陌生。


起初 Tony K. 的基本选项:

def withName(n: String) = Person(n, address)

看起来很有希望,但我有很多扩展 PersonInfo 的类。这意味着在每一个中我都必须重新实现定义,大量的打字和剪切和粘贴,只是为了做一些简单的事情。如果我将特征 PersonInfo 转换为普通类并将所有定义放入其中,那么我会遇到如何返回 Person 而不是 PersonInfo 的问题?是否有一个聪明的 scala 东西可以以某种方式在 trait 或超类中实现并让所有子类真正扩展?

据我所见,当示例非常简单时,2 或 3 个参数在 scala 中所有工作都非常好,但是当你有几十个参数时,它变得非常乏味和不可行。

奇怪加拿大的PersonContext 是我觉得类似的,还在想这个。我想如果我有 43 个参数,我需要分解为多个临时类,以便将参数泵入 Person。

复制选项也很有趣,很神秘,但打字少了很多。

来自 java 我希望从 scala 中获得一些聪明的技巧。

4

3 回答 3

10

案例类有一个预定义的copy方法,您应该使用它。

case class Person(name: String, age: Int)

val mike = Person("Mike", 42)

val newMike = mike.copy(age = 43)

这是如何运作的?copy只是编译器为您编写的方法之一(除了等)equalshashCode在这个例子中是:

def copy(name: String = name, age: Int = age): Person = new Person(name, age)

nameage此方法中的值会影响外部范围内的值。如您所见,提供了默认值,因此您只需指定要更改的值。其他默认为当前实例中的内容。

于 2012-12-13T05:41:59.523 回答
5

scala中存在var的原因是为了支持可变状态。在某些情况下,可变状态确实是您想要的(例如出于性能或清晰度的原因)。

不过,您是对的,鼓励使用不可变状态的背后有很多证据和经验。事情在许多方面都做得更好(并发性、清晰的理由等)。

您的问题的一个答案是为相关类提供突变方法,这些方法实际上不会改变状态,而是返回一个带有修改条目的新对象:

case class Person(val name : String, val address : String) {
   def withName(n : String) = Person(n, address)
   ...
}

这个特定的解决方案确实涉及编码可能很长的参数列表,但仅限于类本身。它的用户很容易下车:

val p = Person("Joe", "N St")
val p2 = p.withName("Sam")
...

如果您考虑要改变状态的原因,那么事情就会变得更加清晰。如果您正在从数据库中读取数据,您可能有很多原因需要改变对象:

  • 数据库本身发生了变化,你想自动刷新内存中对象的状态
  • 您想对数据库本身进行更新
  • 你想传递一个对象,并让它在所有地方都被方法改变

在第一种情况下,不可变状态很容易:

val updatedObj = oldObj.refresh

第二种要复杂得多,有很多方法可以处理它(包括带有脏字段跟踪的可变状态)。看看像 Squery 这样的库是值得的,您可以在其中使用漂亮的 DSL 编写内容(请参阅http://squeryl.org/inserts-updates-delete.html)并完全避免使用直接对象突变。

最后一个是由于复杂性的原因您通常想要避免的那个。这样的事情很难并行化,难以推理,并导致各种错误,其中一个类引用另一个类,但不能保证它的稳定性。这种用法是我们正在谈论的形式的不可变状态尖叫的用法。

于 2012-12-13T04:30:07.793 回答
0

Scala 采用了函数式编程的许多范例,其中之一是专注于使用具有不可变状态的对象。这意味着远离类中的 getter 和 setter,而是选择执行上面@Tony K. 建议的操作:当您需要更改内部对象的“状态”时,定义一个返回新Person对象的函数。

尝试使用不可变对象可能是首选的Scala 方式。

关于 22 参数的问题,你可以创建一个上下文类,传递给 Person 的构造函数:

case class PersonContext(all: String, of: String, your: String, parameters: Int)
class Person(context: PersonContext) extends PersonInfo { ... }

如果您发现自己经常更改地址并且不想通过PersonContextrigamarole,您可以定义一个方法:

def addressChanger(person: Person, address: String): Person = {
    val contextWithNewAddress = ...
    Person(contextWithNewAddress)
}

您可以更进一步,并定义一个方法Person

class Person(context: PersonContext) extends PersonInfo {
    ...
    def newAddress(address: String): Person = {
        addressChanger(this, address)
    }
}

在你的代码中,你只需要记住,当你更新你的对象时,你经常会得到新的对象作为回报。一旦你习惯了这个概念,它就会变得非常自然。

于 2012-12-13T05:14:19.763 回答