Переменные Scala
Переменная — это удобный заполнитель, используемый для ссылки на адрес компьютерной памяти. После создания переменная занимает определённый объём памяти.
В зависимости от типа данных переменной операционная система выделяет память и решает, что будет храниться в зарезервированной памяти. Следовательно, назначая переменным разные типы данных, вы можете хранить в этих переменных целые числа, десятичные дроби или буквы.
Объявление переменной
Прежде чем изучать, как объявлять переменные и константы, давайте сначала разберёмся с переменными и константами.
- Переменная:Величина, значение которой может изменяться во время выполнения программы, называется переменной. Например: время, возраст.
- Константа:Величина, значение которой не изменяется во время выполнения программы, называется константой. Например: число 3, символ 'A'.
В Scala используйте ключевое слово"var"для объявления переменных, а ключевое слово"val"для объявления констант.
Неизменяемая переменная (val):
- Используя
valКлючевое слово объявляет неизменяемую переменную, означающую, что после присваивания её значение не может быть изменено. - Аналогично Java
finalпеременной.
Изменяемая переменная (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]
Пример
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
Явное объявление помогает улучшить читаемость и удобство сопровождения кода, особенно когда типы трудно вывести или их легко перепутать.
Пример
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
Пример
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)
Пример
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-выражении можно одновременно объявить несколько переменных для итерации и создания новых коллекций.
Пример
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")
}
}