Переменные Scala

Переменная — это удобный заполнитель, используемый для ссылки на адрес компьютерной памяти. После создания переменная занимает определённый объём памяти.

В зависимости от типа данных переменной операционная система выделяет память и решает, что будет храниться в зарезервированной памяти. Следовательно, назначая переменным разные типы данных, вы можете хранить в этих переменных целые числа, десятичные дроби или буквы.

Объявление переменной

Прежде чем изучать, как объявлять переменные и константы, давайте сначала разберёмся с переменными и константами.

  • Переменная:Величина, значение которой может изменяться во время выполнения программы, называется переменной. Например: время, возраст.
  • Константа:Величина, значение которой не изменяется во время выполнения программы, называется константой. Например: число 3, символ 'A'.

В Scala используйте ключевое слово"var"для объявления переменных, а ключевое слово"val"для объявления констант.

Неизменяемая переменная (val):

  • ИспользуяvalКлючевое слово объявляет неизменяемую переменную, означающую, что после присваивания её значение не может быть изменено.
  • Аналогично Javafinalпеременной.

Изменяемая переменная (var):

  • ИспользуяvarКлючевое слово объявляет изменяемую переменную, значение которой можно изменять несколько раз в течение времени выполнения программы.
  • Аналогично обычным переменным в Java.

Пример объявления переменной выглядит следующим образом:

var myVar : String = "Foo"
var myVar : String = "Too"

Выше определена переменная myVar, которую мы можем изменять.

Пример объявления константы выглядит следующим образом:

val myVal : String = "Foo"

Выше определена константа myVal, которую нельзя изменить. Если программа попытается изменить значение константы myVal, это вызовет ошибку компиляции.


Объявление типа переменной

Тип переменной объявляется после имени переменной и перед знаком равенства. Синтаксис определения типа переменной выглядит следующим образом:

var VariableName : DataType [=  Initial Value]

或

val VariableName : DataType [=  Initial Value]

Пример

object VariableExample {
  def main(args: Array[String]): Unit = {
    // Объявить неизменяемую переменную
    val immutableVariable: Int = 10
    println(s"Неизменяемая переменная: $immutableVariable")

    // Объявить изменяемую переменную
    var mutableVariable: Int = 20
    println(s"Изменяемая переменная: $mutableVariable")

    // Изменить значение изменяемой переменной
    mutableVariable = 30
    println(s"Обновлённая изменяемая переменная: $mutableVariable")

    // Неизменяемым переменным нельзя присваивать новое значение; это вызовет ошибку компиляции
    // immutableVariable = 15 // Раскомментирование этой строки вызовет ошибку компиляции
  }
}

Вывод вышеприведённого кода:

Immutable Variable: 10
Mutable Variable: 20
Updated Mutable Variable: 30

Соглашения об именовании переменных

Допустимые символы:

  • Имена переменных должны начинаться с буквы (A-Z или a-z) или подчеркивания (_).
  • Последующие символы могут быть буквами, цифрами (0-9) или подчеркиваниями.
  • Имена переменных не могут быть ключевыми словами Scala.

Именование в стиле Camel Case:

  • Имена переменных обычно используют camel case, где первое слово начинается со строчной буквы, а первая буква последующих слов — заглавная.
  • Например:myVariableName, userAge, accountBalance。

Избегайте использования имен переменных из одного символа:

  • За исключением распространенных переменных-счетчиков (таких какi, j, k), по возможности избегайте использования имен переменных из одного символа, чтобы улучшить читаемость кода.

Осмысленные имена переменных:

  • Имена переменных должны ясно выражать свое назначение или смысл, избегая расплывчатых или бессмысленных имен.
  • Например:val age: Int = 25лучше, чемval a: Int = 25。

Специфичные для Scala соглашения об именовании:

  • Старайтесь избегать имён переменных, начинающихся с подчёркивания, так как обычно они используются для обозначения внутренних или приватных переменных.
  • Комбинации букв и символов можно использовать для именования функций и методов, но в именовании переменных это встречается редко.
  • Избегайте использования комбинаций символов, похожих на операторы (таких как++,--) в качестве имён переменных, так как это делает код трудным для чтения и понимания.

Справочник по типам переменных

В Scala необязательно указывать тип данных при объявлении переменных и констант. Когда тип данных не указан, он выводится из начального значения переменной или константы.

Следовательно, если вы объявляете переменную или константу, не указывая её тип данных, необходимо задать её начальное значение; в противном случае возникнет ошибка.

  • Явное объявление типа: явно укажите тип переменной.
  • Вывод типа: опустите объявление типа и позвольте компилятору вывести тип.

Механизм вывода типов Scala может автоматически определять тип переменной, поэтому мы можем опустить объявление типа:

val inferredInt = 42  // 编译器推断为 Int
val inferredDouble = 3.14  // 编译器推断为 Double
val inferredString = "Hello, Scala!"  // 编译器推断为 String
val inferredBoolean = true  // 编译器推断为 Boolean

Вывод типов делает код более кратким, но в сложных сценариях явные объявления типов помогают избежать путаницы.

Для явного объявления типа после имени переменной ставятся двоеточие и тип данных:

val explicitInt: Int = 42
val explicitDouble: Double = 3.14
val explicitString: String = "Hello, Scala!"
val explicitBoolean: Boolean = true

Явное объявление помогает улучшить читаемость и удобство сопровождения кода, особенно когда типы трудно вывести или их легко перепутать.

Пример

object VariableTypesExample {
  def main(args: Array[String]): Unit = {
    // Явное объявление типа
    val explicitInt: Int = 42
    val explicitDouble: Double = 3.14
    val explicitString: String = "Hello, Scala!"
    val explicitBoolean: Boolean = true

    // Вывод типов
    val inferredInt = 42  // Компилятор выводит Int
    val inferredDouble = 3.14  // Компилятор выводит Double
    val inferredString = "Hello, Scala!"  // Компилятор выводит String
    val inferredBoolean = true  // Компилятор выводит Boolean

    // Изменяемая переменная
    var mutableInt: Int = 10
    println(s"Начальное значение mutableInt: $mutableInt")
    mutableInt = 20  // Изменить значение переменной
    println(s"Обновлённое значение mutableInt: $mutableInt")

    // Вывести все переменные
    println(s"Явный Int: $explicitInt")
    println(s"Явный Double: $explicitDouble")
    println(s"Явный String: $explicitString")
    println(s"Явный Boolean: $explicitBoolean")

    println(s"Выведенный Int: $inferredInt")
    println(s"Выведенный Double: $inferredDouble")
    println(s"Выведенный String: $inferredString")
    println(s"Выведенный Boolean: $inferredBoolean")
  }
}

Вывод вышеприведённого кода:

Initial mutableInt: 10
Updated mutableInt: 20
Explicit Int: 42
Explicit Double: 3.14
Explicit String: Hello, Scala!
Explicit Boolean: true
Inferred Int: 42
Inferred Double: 3.14
Inferred String: Hello, Scala!
Inferred Boolean: true

Объявление нескольких переменных в Scala

В Scala можно объявить несколько переменных одновременно. Это не только делает код более кратким, но и обеспечивает связь нескольких переменных, объявленных в одной строке.

В Scala можно объявлять несколько переменных одновременно с помощью таких методов, как разделение запятыми, деструктуризация кортежей и for-выражения.

Вы можете объявить несколько переменных в одной строке, разделяя их запятыми:

val xmax, ymax = 100  // xmax, ymax都声明为100

Пример

object MultipleVariables {
  def main(args: Array[String]): Unit = {
    // Объявить несколько неизменяемых переменных одновременно
    val a, b, c: Int = 5
    println(s"a: $a, b: $b, c: $c")

    // Объявить несколько изменяемых переменных одновременно
    var x, y, z: Int = 10
    println(s"x: $x, y: $y, z: $z")

    // Изменить значение изменяемых переменных
    x = 20
    y = 30
    z = 40
    println(s"Updated x: $x, y: $y, z: $z")
  }
}

Если возвращаемое значение метода — это кортеж, мы можем использовать val для объявления кортежа:

scala> val pa = (40,"Foo")
pa: (Int, String) = (40,Foo)

Пример

object TupleDestructuring {
  def main(args: Array[String]): Unit = {
    // Использование деструктуризации кортежа для одновременного объявления нескольких переменных
    val (a, b, c) = (1, 2, "hello")
    println(s"a: $a, b: $b, c: $c")

    // Использование деструктуризации кортежа для одновременного объявления нескольких изменяемых переменных
    var (x, y, z) = (10, 20, "world")
    println(s"x: $x, y: $y, z: $z")

    // Изменить значение изменяемых переменных
    x = 30
    y = 40
    z = "Scala"
    println(s"Updated x: $x, y: $y, z: $z")
  }
}

Объявление нескольких переменных с помощью for-выражений

В for-выражении можно одновременно объявить несколько переменных для итерации и создания новых коллекций.

Пример

object ForComprehension {
  def main(args: Array[String]): Unit = {
    // Объявление нескольких переменных одновременно для итерации
    val numbers = List((1, "one"), (2, "two"), (3, "three"))
    for ((number, word) <- numbers) {
      println(s"Number: $number, Word: $word")
    }

    // Используйте for-выражение для создания новой коллекции
    val newNumbers = for {
      (number, word) <- numbers
    } yield (number * 2, word.toUpperCase)

    println(s"New Numbers: $newNumbers")
  }
}
Другие расширения