Переменные в Scala

Scala

Проверьте новое открытое курса DataCamp по Scala: Введение в Scala.

Scala широко используется Data Scientists, работающими с большими объемами данных вместе с Apache Spark в сфере Big Data. Это язык, сочетающий обобщенность и функциональные особенности, а также многие другие необходимые особенности, указаны ниже:

Scala является статическим типизированным языком, где тип данных для переменной определяется до ее использования. Тип проверки выполняется во время компиляции, а не во время выполнения.
Он также является “сильно типизированным” языком, где переменные проверяются до того, как они принимают участие в операции.
Он также поддерживает вference Type, где компилятор выводит тип из выражения или литералов, поэтому определение типа переменной является опциональным.

В данном руководстве вы покроете следующие темы:

Переменные
Правила определения переменных в Scala
Метаболические переменные
Неметаболические переменные
多重宣言和分配规则
Область видимости переменных в Scala

Переменные

Переменные – это названные области в памяти, для которых компилятор выделяет место согласно типу данных соответствующей переменной. В Scala переменную объявляют с помощью следующей синтаксиса:

val or val variable_name: variable_datatype = value;

В вышеуказанном синтаксисе переменную можно определить двумя способами, используя ключевые слова ‘var’ или ‘val’. Она состоит из ‘имя_переменной’ как вашей новой переменной, за которым следует двоеточие. Тип данных переменной ‘тип_данных_переменной’, который может быть любым допустимым типом данных. После этого ‘значение’ присваивается ‘имени_переменной.’

Например:

val varValue: Byte = 8;

Ключевое слово ‘val’ используется для определения переменной, ‘varValue’ – это имя переменной. Она имеет тип данных ‘Byte’ и содержит значение 8. ‘Byte’ – это 8-битное знаковое значение, диапазон которого составляет от 2⁻⁷ до 2⁷−1.

‘тип_данных_переменной’ может быть любым типом данных, существующим в Scala, и включает в себя следующие.

Int: 32-битное знаковое (положительное или отрицательное значение), диапазон которого составляет от 2⁻³¹ до 2³¹−1.
Byte: 8-битное знаковое значение, диапазон которого составляет от 2⁻⁷ до 2⁷−1.
Short: 16-битное знаковое значение, диапазон которого составляет от 2⁻¹⁵ до 2¹⁵−1.
Float: может быть 32-битным или 64-битным.

Также, другие типы данных, такие как Long, Char, Boolean, Char, String, Boolean, Null имеют свой собственный диапазон и детальное объяснение приводится в учебнике Beginner’s Guide to Scala. Кроме того, для ‘variable_datatype’ следует начать с заглавной буквы, т.е. Int содержит ‘I’, что указывает на то, что все вышеуказанные типы данных являются объектами в Scala.

Правила определения переменных в Scala

Правила и соглашения для определения переменных в Scala таковы:

Имя переменной начинается с маленького camelCase. Например, в имя переменной ‘nameOfGirl’ содержится ‘n’ как маленькая буква. Затем все начальные буквы слова учитывают ‘O’ и ‘G’.
Имя переменной не должно содержать зарезервированное слово или ключевое слово, определенное в Scala.
Имя переменной может содержать знак доллара (‘$’) и знак подчерки (‘_’). Однако другие специальные символы, такие как ‘#’,’&’, и т. д., не допускаются. Кроме того, рекомендуется не использовать подчерк.
Пробелы (табуляция, пробел) не допускаются в имени переменной.
Имя переменной должно начинаться с буквы и не может начинаться с цифры или других символов.

Переменные изменяемого типа

Переменные изменяемого типа позволяют изменять значения переменных даже после их объявления.

Синтаксис переменной изменяемого типа приводится ниже:

var variable_name : variable_datatype = value;

Синтаксис изменяемой переменной также может быть определен следующим образом:

var variable_name = value;

Пример изменяемой переменной показан ниже:

var nameOfThing: String = "Car";

Выше приведен пример, содержащий var как ключевое слово, которое используется для определения изменяемых переменных. Имя переменной – ‘nameOfThing’. За ним следует двоеточие с типом данных переменной ‘String’. Значение, хранящееся в памяти, будет ‘Car’.

Выше приведенный пример изменяемой переменной с другим синтаксисом может быть сделан следующим образом:

var nameOfThing = "Car";

Вы можете определить свою переменную без указания типа данных, как это было сделано выше. Компилятор Scala автоматически определяет, что это тип данных ‘String’, что называется Type Inference.

Вы можете легко изменить значение переменной, как показано ниже:

nameOfThing = "Bike";
print(nameOfThing)

Значение переменной изменится с “Car” на “Bike”. Вывод будет “Bike”, потому что ключевое слово ‘var’ позволяет изменять значение переменной (Источник: Variables in 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)//Действительный

В указанном выше коде, переменная ‘разность’ находится в локальной области видимости, объявленной внутри метода ‘sub’, и операция вычитания будет давать допустимые результаты, но печать значения за пределами метода ‘sub’ приведёт к ошибке. Существует также глобальная область видимости, в которой переменная ‘globalVar’ может быть доступна в любом месте программы, и с ней могут выполняться любые операции.

В Scala существует три типа области видимости переменных (Источник: Scala – Переменные):

Локальные переменные
Поля
Параметры метода

Локальные переменные

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

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

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’. Вычисление и печать результата будут осуществлены внутри метода, что приведёт к правильному выводу.

Поля

Те переменные, которые определены внутри класса, известны как переменные поля, которые могут быть любого типа, либо изменяемыми, либо неизменяемыми переменными. Модификатор доступа автоматически становится публичным, если переменная объявлена внутри класса, но не должна быть определена внутри любого метода, где переменная доступна в любой части программы. Однако приватная переменная может быть доступна внутри определенного класса, но не может быть доступна за пределами области класса или даже в объекте.

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’ с двумя параметрами метода: высота и ширина. Значение целого числа 4 и 5 передаются при вызове ‘calculate’ с использованием экземпляра объекта a.

Заключение

Поздравляем, вы добрались до конца этого урока!

В этом уроке вы изучили переменные в Scala, правила для 定义 переменных, различные типы переменных с множественным объявлением и присваиванием, а также Scope переменных.

Если вы хотите узнать больше о Scala, пройдите курс DataCamp ‘Введение в Scala‘.

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