Scala中的变量

教程
Scala

查看DataCamp最近推出的Scala课程：Scala入门。

Scala在大数据分析领域，与Apache Spark一起处理大量数据时，被数据科学家广泛使用。它是一种既面向对象又具备函数式编程特性的语言，以下是其其他重要特性：

  1. Scala是一种静态类型语言，变量在使用前需要定义数据类型。类型检查是在编译时进行，而不是在运行时。
  2. 它也是一种“强类型”语言，变量在执行操作前会进行类型检查。
  3. Scala还支持类型推断，编译器会从表达式或字面量中推断出类型，因此声明变量的类型是可选的。

在本教程中，您将学习以下主题：

变量

变量是内存中的命名空间，编译器根据相应变量的数据类型分配保留的位置。在Scala中，变量的声明语法如下：

val or val variable_name: variable_datatype = value;

在上述语法中，可以通过使用’var’或’val’关键字以两种方式之一来定义变量。它由’variable_name’作为你的新变量，后跟一个冒号。变量的数据类型是’variable_datatype’，可以是任何有效的数据类型。之后，’value’符号被赋值给’variable_name’。

例如：

val varValue: Byte = 8;

‘val’是定义变量的关键字，’varValue’是变量名。它是’Byte’数据类型，并包含值8。’Byte’是一个8位有符号值，其范围从2−7到27−1。

上述的’variable_datatype’可以是Scala中存在的任何数据类型，如下所示。

  1. Int：是一个32位有符号（正数或负数），其范围从2−31到231−1。
  2. Byte：它是一个8位有符号值，其范围从2−7到27−1。
  3. Short：它是16位有符号值，其范围从2−15到215−1。
  4. Float：它可以是32位或64位。

同样，其他数据类型如Long、Char、Boolean、Char、String、Boolean、Null也有自己的范围，并在Scala入门教程中给出了详细解释。此外，’variable_datatype’应首字母大写，即Int包含’I’，这表明上述所有数据类型都是Scala中的对象。

Scala中定义变量的规则

Scala中定义变量的规则和约定如下：

  1. 变量名以小驼峰命名法开头。例如，变量名’nameOfGirl’中包含’n’作为小写字母。之后，将单词开头的字母大写，如’O’和’G’。
  2. 变量名不应包含Scala中定义的保留字或关键字。
  3. 变量名可以包含美元符号(‘$’)和下划线(‘_’)。然而，其他特殊字符如’#’、’&’等是不允许的。同时，不鼓励使用下划线。
  4. 变量名中不允许有空白字符（制表符、空格）。
  5. 变量名必须以字母开头，不能以数字或其他字符开头。

可变变量

可变变量允许在变量声明后更改变量的值。

可变变量的语法如下：

var variable_name : variable_datatype = value;

可变变量的语法也可以定义如下：

var variable_name = value;

可变变量的示例如下：

var nameOfThing: String = "Car";

上面的例子包含 var 作为关键字，用于定义可变变量。变量的名称是 ‘nameOfThing’。后面跟着一个冒号，变量的数据类型为 ‘String’。它在内存中存储的值将是 ‘Car’。

上面的可变变量的不同语法示例如下：

var nameOfThing = "Car";

你可以像上面那样定义变量而不指定变量的数据类型。Scala 编译器会自动将其确定为 ‘String’ 数据类型，这称为 类型推断。

你可以轻松地更改变量的值，如下所示：

nameOfThing = "Bike";
print(nameOfThing)

变量的值将从 “Car” 变为 “Bike”。输出将是 “Bike”，因为 ‘var’ 关键字允许你更改变量的值（来源：Scala 中的变量）。

不可变变量

不可变变量是指一旦创建其值就不能更改的变量，并使用 ‘val’ 关键字声明。

不可变变量的语法如下：

val variable_name : variable_data type = value;

不可变变量的语法也可以定义如下：

val variable_name = value;

不可变变量的示例如下：

val numberOfThing: Int = 2;

上述示例中的 `val` 是定义不可变变量的关键字，变量的名称为 ‘numberOfThing’。后面跟着一个冒号和变量数据类型为 ‘Int’，以及在内存中存储的值为2。

上述使用不同语法的不可变变量示例可以如下进行定义：

val numberOfThing = 2;

您可以在没有变量数据类型的情况下定义您的变量，就像上面那样，Scala编译器会自动推断出它是 ‘Int’ 数据类型。这个过程称为类型推断（来源：Scala中的变量）。

您不能像下面这样更改变量的值：

numberOfThing = 7;

上述示例将导致错误，如 “error: not found: value numberOfThing”，这表明无法如所示进行重新赋值：

多个声明和赋值

在Scala中，使用 ‘var’ 关键字可以实现多个声明，变量名称用逗号分隔，并用 “=” 符号与变量的值分隔。

var (x, y, z) = (5, 4.5, "Sit")

在上述示例中，您可以看到所有变量x、y和z分别被赋值为5、4.5和”Sit”。

在Scala中，使用 ‘val’ 关键字可以在同一行实现多个赋值，变量名称用逗号分隔，并用 “=” 符号与变量的值分隔。

val a, b, c = 1;

在上述示例中，您可以看到所有变量a、b和c被赋值为1。

变量的作用域

作用域是代码中指定块内的变量的可见性范围。变量可以在局部作用域或全局作用域中定义。例如：

var globalVar = 10
def sub(){
var difference = 9-4;
}
print(difference)//错误
print(globalVar)//有效

在上面的代码中，’difference’ 变量在局部作用域内，它在 ‘sub’ 方法内声明，减法操作将得到有效结果，但在 ‘sub’ 方法外部打印值将导致错误。还有一个全局作用域，变量 ‘globalVar’ 可以在程序的任何地方访问，并且可以对其进行任何操作。

Scala 中变量的作用域有三种类型（来源：Scala – 变量）：

  1. 局部变量
  2. 字段
  3. 方法参数

局部变量

局部变量是在方法内声明的可变或不可变变量，只能在方法内部访问，但不能在外部访问。

下面是一个关于局部变量的简单示例：

class Perimeter  
{
    def triangle()  
    {
        var side1 = 10;
        var side2 = 20;
        var side3 = 30;

        var total = side1+side2+side3;
        print("Perimeter of the  triangle is: " + total);
    }
}

object Test  
{

    def main(args:Array[String])  
    {
        val p1 = new Perimeter()
        p1.triangle()
    }
}

defined class Perimeter
defined object Test

上面的代码给出了结果：

三角形的周长是：60

上面的程序包含一个名为 ‘Perimeter’ 的类和一个名为 ‘Test’ 的对象，其中有一个名为 ‘triangle’ 的方法，该方法有三个可变变量 side1、side2、side3。计算和打印结果将在方法内部完成，这将得到正确的输出。

字段

类内部定义的变量被称为字段变量，它们可以是任何类型的变量，无论是可变的还是不可变的。如果变量在类内部声明，则访问修饰符将自动是public的，而且变量不应该在方法内部定义，因为这样变量才能在程序中的任何地方访问。然而，私有变量可以在定义的类内部访问，但不能在类的范围之外或甚至在对象中访问。

class FieldExample
{
  var value1 = 10;
  private var value2 = 30;
  def operation()
  {
    println("Value of value1:"+value1)
  }
  println("Value of value2: "+value2);
}

object Demo
{
  def Main(args:Array[String])
  {
    val obj = new FieldExample()
    obj.operation()
    print(obj.value1)//Valid
    print(obj.value2)


  }
}

defined class FieldExample
defined object Demo

上面的代码给出结果：

value2的值：30
value1的值：10
10

上述程序包含一个名为”FieldExample”的类，”Demo”的对象和一个名为”operation”的方法。公共变量value1可以通过点表示法访问，其值打印为10。私有变量value2为30，尝试访问该变量并将值打印出来将导致错误。

方法参数

方法参数是在调用方法时接受值的变量，该变量必须是可变的，使用”val”关键字定义。此外，当创建对它的引用时，该变量可以在方法外部访问。

您可以通过以下简单示例了解方法参数：

class Triangle
{
    def calculate(height: Int, width: Int)
    {
        var result = 0.5*(height+width);
        println("Area of triangle is: " + result);
    }
}

object Area  
{
     def main(args:Array[String])
    {
        val a = new Triangle()
        a.calculate(4,5);
    }
}

defined class Triangle
defined object Area

上述代码给出结果：

三角形的面积是：4.5

上面的程序包含一个名为’Triangle’的类。它包含一个名为’calculate’的方法，该方法有两个参数：高度和宽度。当使用对象实例a调用’calculate’方法时，整数值4和5会被传递。

结论

恭喜你，你已经完成了本教程的阅读！

在本教程中，你了解了Scala的变量、定义变量的规则、多种类型的变量以及它们的多次声明和赋值，还包括了变量的作用域。

如果你想了解更多关于Scala的知识，可以参加DataCamp的Scala入门课程。

Source:
https://www.datacamp.com/tutorial/variables-in-scala