Scala初始化运行时字段中更改的元素的正确方法：占位符/null、None或zero元素？

我得到了一个类，其中的字段在初始化时的值未知。但之后，在运行时，将获得该值并将其设置为字段，仅设置为字段

我想确定该字段最好使用什么样的第一次初始化。正如我所读到的，有这样的方法：

使用占位符

\uuu

或

null

[坏方法]：

var name: String = _
var nextUser: User = null

var name: Option[String] = None
var nextUser: Option[User] = None

使用

None

，而不是在我的代码

中使用一些（v）

[很好，但是冗长的]：

var name: String = _
var nextUser: User = null

var name: Option[String] = None
var nextUser: Option[User] = None

使用“零”元素：

使用存根：

var name: String = "undefined"
var nextUser: User = UndefinedUser

我发现了3个问题：

从

Some（）

对字段使用

var

是不好的，因为字段实际上只需通过值设置一次，但在运行时

编写

updateUser

类方法是不好的

现在，我在该字段中使用了

None

，因为对于我库中没有的某些类型，没有任何

构造函数

或

空值

\“零”值：

你能给我什么建议？

---

我需要类似于lazy var的东西或任何好的建议。

建议首先避免使用这种可变数据结构

使类不可变，并更改方法，如

updateUser

，以返回新的更新实例，而不是修改当前实例

但如果必须执行此操作，

选项

专门针对可能存在或不存在值的情况而设计。像

map

和

getOrElse

这样的方法使使用

选项

值变得简单（且安全），开销很小

---

例如，这就是如何安全地计算

name

和

hoursToStart

：

val name = classInstance.myThread.fold("NoName")(_.name)
val hoursToStart = classInstance.myTransformUnit.fold(0)(_.waitTime.hours)

如果要使用多个

选项

值，请将

用于

，如下所示：

for {
  thread <- classInstance.myThread
  user <- classInstance.nextUser
  unit <- classInstance.myTransformUnit
} {
  // Code that uses thread, user, and unit
}

用于{
thread建议首先避免使用这样的可变数据结构

使类不可变，并更改方法，如
updateUser
，以返回新的更新实例，而不是修改当前实例

但如果必须这样做，
选项
是专门为值可能存在或可能不存在的情况而设计的。像
映射
和
getOrElse
这样的方法使使用
选项
值变得简单（且安全），开销非常小


例如，这就是如何安全地计算
name
和
hoursToStart
：

val name = classInstance.myThread.fold("NoName")(_.name)
val hoursToStart = classInstance.myTransformUnit.fold(0)(_.waitTime.hours)

如果要使用多个
选项
值，请将
用于
，如下所示：

for {
  thread <- classInstance.myThread
  user <- classInstance.nextUser
  unit <- classInstance.myTransformUnit
} {
  // Code that uses thread, user, and unit
}

用于{
线程和什么是不可变类最适合使用的：
copy（）
或返回新实例的own方法？
copy（）
似乎很简单，但使用返回新实例的方法有什么好处吗？我将提供一个在内部使用
copy
的方法，类似这样：
defwithuser（user:user）=此.copy（用户=用户）
。但最好是延迟创建对象，直到获得所需的数据。只需延迟创建此实例直到获得所有信息，或者使用一些语言功能（如
lazy
）进行延迟？如果可能，延迟到获得所有信息。对于immutable类来说，最适合使用的方法是：
copy（）
或返回新实例的own方法？
copy（）
似乎很简单，但使用返回新实例的方法有什么好处吗？我将提供一个在内部使用
copy
的方法，类似这样：
def with user（user:user）=this.copy（user=user）
。但最好是延迟创建对象，直到获得所需的数据。只需延迟创建此实例，直到获得所有信息，或者使用一些语言功能（如
lazy
）进行延迟，如果可能的话，延迟到获得所有信息。