介绍

在本文中，我们将讨论Scala编程语言的一些基本概念。
即使它涵盖了非常基本的概念，但了解它们也非常重要。

我们可以回答一些问题，例如什么是val，var和def？它们之间有什么区别？什么时候进行评估？ val和lazy val有什么区别？开始基于Scala的项目时需要这些东西

Scala" val"用法

在Scala中，" val"修饰符用于定义常量。
val表示常量或者不可变，表示一旦创建就无法更改其值。

例：

scala> val name:String = "Scala"
name: String = Scala

scala> name
res2: String = Scala

scala> name = "Java"
:11: error: reassignment to val
     name = "Java"
          ^

其中我们可以看到禁止重新分配给val。
这意味着val用于定义不可变数据。

如何评估Scala的" val"？

在Scala中，" val"用于定义常量。
它只评估一次。
仅在定义时评估它们。
一旦对其求值，它将为所有引用重复使用相同的值。

它不会在我们每次访问它时进行评估。

我们将通过一个简单的示例来探索此规则，如下所示：

例：

object ValApp extends App{
val number = { println("Constant number is initialized."); 99 }
println("Before Accessing 'number' constant:")
println(number + 1)
println(number + 1)
println(number + 1)
}

输出：-其中我仅出于简化目的使用所有REPL命令。
我们可以使用任何Scala IDE(例如Eclipse Scala IDE或者IntelliJ IDE(我最喜欢的IDE))对其进行测试。

F:\>scalac ValApp.scala

F:\>scala ValApp
Constant number is initialized.
Before Accessing 'number' constant:
100
100
100

其中我们可以观察到"数字"常量在定义时仅被评估一次，这就是为什么在访问变量之前先打印println输出的原因。
即使我们已经访问过3次常数，它也只能初始化一次并显示"常数已初始化"。
仅发送一次文字。

Scala" var"用法

在Scala中，" var"修饰符用于定义变量。
var表示变量或者可变变量，表示一旦创建它就可以更改其值。

例：

scala> var name:String = "Scala"
name: String = Scala

scala> name
res0: String = Scala

scala> name = "Java"
name: String = Java

scala> name
res1: String = Java

其中我们可以看到允许重新分配给var。
由于var用于定义Mutable数据，因此我们可以在创建变量后更改其值。

如何评估Scala的" var"？

在定义时评估var仅评估一次

例：

object VarApp extends App{
val number = { println("Variable number is initialized."); 99 }
println("Before Accessing 'number' variable:")
println(number + 1)
println(number + 1)
println(number + 1)
}

输出：

F:\>scalac VarApp.scala

F:\>scala VarApp
Variable number is initialized.
Before Accessing 'number' variable:
100
100
100

Scala" def"用法

在Scala中，def用于定义函数或者方法。
方法或者函数可能具有或者不具有参数，并且可能具有或者不具有返回类型。

例：

scala> def add(num1:Int, num2:Int): Int = num1 + num2
add: (num1: Int, num2: Int)Int

scala> add(11,22)
res2: Int = 33

如上所示，仅在调用方法或者函数时才对其进行评估。

如何评估Scala的" def"？

在Scala中，def的计算是延迟的。
在定义时不进行评估。
每当我们调用它时，都会对其进行评估。
每次调用它时都会对其进行评估。

例：

object DefApp extends App{
def tax = {
  println("Function execution started.")
  1100
}

println(tax)
println(tax)
println(tax)
}

输出：

Before making a cll to Function:
Function execution started.
1100
Function execution started.
1100
Function execution started.
1100

如上面的输出所示，仅在调用方法或者函数时才对其进行评估。
否则，将不进行评估。

如何评估Scala的"懒惰值"？

众所周知，val用于定义常量或者不可变数据。
同样，我们使用"惰性值"定义不可变数据。

但是，懒惰val只能被懒惰地评估一次。
当我们第一次使用它时，它只会被评估一次。
在定义时不进行评估。
我们不会在每次访问它时对其进行评估。

例：

object LazyValApp extends App{
lazy val number = { println("Constant number is initialized."); 99 }
println("Before Accessing 'number' constant:")
println(number + 1)
println(number + 1)
println(number + 1) 
}

输出：

Before Accessing 'number' constant:
Constant number is initialized.
100
100
100

其中我使用的是ValApp的相同示例，但仅从" val"更改为" lazy val"。

如果我们观察到此输出，则可以看到没有看到"常量号已初始化"。
定义时的输出。
我们仅在首次访问时才看到此消息。
它仅一次显示该消息。
凉！。

注意：-我们不能对var使用"惰性"修饰符。
只能用于val。
例：

scala> lazy var a = 0
:1: error: lazy not allowed here. Only vals can be lazy
lazy var a = 0
   ^

var Vs lazy val

其中我们将讨论Scala语言中val和惰性val构造之间的一些异同。

val和惰性val构造之间的相似之处：

• 两者都用于定义常量或者不可变数据
• 两者仅被评估一次。

val和惰性val构造之间的区别：

• " val"是在定义时评估的，表示"渴望"。

• 只有当我们懒惰地访问它时，才评估"惰性值"。

Scala val，var，lazy val和def构造In-Brief

在前面的部分中，我们通过一些简单而有用的示例详细讨论了Scala val，var，lazy val和def构造。
这里有一些要记住的要点。

• " val"用于定义不可变数据。
  在定义时仅对其进行一次评估。

• " var"用于定义可变数据。
  在定义时仅对其进行一次评估。

• 认真评估val和var。

• "惰性值"用于定义不可变数据。
  当我们第一次访问它时，它只会被评估一次。
  这意味着它被懒惰地评估。

• " def"用于定义方法或者功能。
  仅当我们访问它时才对其进行评估，并在每次访问时对其进行评估。
  这意味着它被懒惰地评估。

注意：-在Scala中，每次访问它们时，都会对"按名称"参数进行评估/计算。