Основы функций и методов в Scala

Учебники
Scala

Хотите узнать больше о Scala? Пройдите курс DataCamp Введение в Scala.

Scala – это функциональный язык программирования, который содержит как функции в качестве первоклассных значений, так и методы, и имеет как сходства, так и различия. И функции, и методы представляют собой блок многократно используемого кода, а также используются для хранения повторяющегося кода в одном месте, что позволяет вызвать функцию для выполнения определенной конкретной задачи. Они также облегчают отладку и модификацию кода.

Однако функции представляют собой объект, который инициализируется в переменной, а методы начинаются с ключевого слова ‘def’, за которым следует имя метода, список параметров, тело метода с возвращаемым значением.

Декларация и определение метода

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

def 'method_name' ('parameters':'return_type_parameters') : ('return_type_of_method') = {
    'method_body'
     return 'value'
}

Метод в Scala начинается со следующих частей:

  1. ‘def’: ключевое слово, которое используется для объявления методов.
  2. ‘method_name’: – это имя вашего метода, которое пишется в нижнем верблюжьем регистре.
  3. ‘parameters’: – это параметры метода, которые могут не иметь параметров или иметь только один параметр, но разделяются запятой, если параметров больше одного.
  4. ‘return_type_of_parameters’: должен соответствовать типу данных ‘parameters_list’ и является обязательным.
  5. ‘тип_возвращаемого_значения_метода’: является необязательным, но по умолчанию возвращается ‘Unit’, но значение может быть возвращено с помощью ключевого слова ‘return’.
  6. Символ присваивания(‘=’): является необязательным, и если он используется, он присваивает возвращаемое значение, и если его не использовать, метод не будет возвращать ничего.
  7. ‘тело_метода’: это блок кода, заключенный в фигурные скобки ‘{}’ и состоит из необходимой логики или определенных задач или операций.
  8. return: это ключевое слово, используемое для возврата требуемых значений и также для завершения программы, но редко используется в Scala.

Вызов метода

Синтаксис вызова метода в Scala указан ниже:

    method_name(arguments)

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

Метод с именованными аргументами

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

object calculateResult {
      def funSub(x:Int, y:Int) : Int =
   {

       var diff:Int = 0
       diff = x - y

       // return value
       return diff
   }
   def main(args: Array[String]) {

      // Function call
      println("Difference of the value is: " + funSub(8,6));
      println("Difference of the value is " + funSub(y=6,x=8));
   }
}

Вышеуказанная программа дает вывод:
Разница значений: 2
Разница значений: 2

В указанном выше программном коде содержится объект ‘calculateResult’, внутри которого находится метод с именем ‘funSub’, у которого обоие параметры x и y имеют тип возвращения ‘Int’, общий тип возвращения метода также ‘Int’. Затем следует оператор присваивания для присваивания значения возвращаемого значения.Curly braces indicate the start of the method body, where the variable ‘diff’ is initialized with the initial value of 0. The Method call ‘funSub(8,6)’ done in the main method matches 8 to ‘x’ and 6 to ‘y’, and the subtraction operation is carried out, and the value of ‘diff’ is returned and finally gets printed. Similarly, the ‘funSub(x=8,y=6)’ matches 6 to ‘y’ and 8 to ‘x’ to parameters in the method during method call where the order doesn’t matter where a similar operation is done and is return and result gets printed out.

Default Parameter Values

You can specify the default values for the method parameters through the initialization of corresponding values and can leave the method call empty by not passing the argument.

object calculateResult {
      def funSub(x:Int=9, y:Int=6) : Int =
   {

       var diff:Int = 0
       diff = x - y

       // return value
       return diff
   }
   def main(args: Array[String]) {

      // Function call
    print( "The final value is: " + funSub() );

   }
}

The above program gives the output as:
The final value is: 3

В указанном выше программа содержит объект, определенный как ‘calculateResult’, в котором есть метод с именем ‘funSub’ с параметрами x и y, у обоих есть тип возврата ‘Int’, и общий тип возврата метода также ‘Int’, и сразу же идет оператор присваивания, который присвоит возвращаемое значение. Фигурные скобки указывают на начало тела метода, где переменная ‘diff’ инициализируется с начальным значением 0. Вызов метода осуществляется в основном методе, где ‘funSub()’ вызывается и инициализирует x значение 9 и y значение 6, и производится операция, в результате которой возвращается значение ‘diff’ и выводится на экран.

Аргументы переменной длины

Аргументы переменной длины — это аргументы, которые принимают любое количество аргументов и могут быть переданы пользователем или клиентом. Последний параметр в методе объявляется с использованием ‘*’, который должен быть повторен.

object variableArgument {
    def main(args: Array[String]) {
       printAll("Scala", "is", "great")
    }

    def printAll(strings: String*) {
        var i : Int = 0;

      for( value <- strings ){
         println(value);
         i = i + 1;
      }
    }
}

В указанной выше программе выводится:
Scala
велика
отлично

Можно видеть, что в указанной программе содержится объект ‘variableArgument’ с методом ‘printAll’, где в конце определены аргументы переменной длины ‘String*’, и при вызове метода может быть передан список строк. Переданный список строк итерируется в цикле и выводится как результат в основной функции.

Рекурсивная функция

Рекурсия – это техника, используемая в функциональном программировании, когда проблема решается путём решения постоянно уменьшающихся подпроблем, которые сходны с исходной проблемой. Чем меньшешие проблемы решены, и их решения применены для получения решений исходной проблемы. Таким образом, это называется разделением и подавлением или уменьшением и подавлением проблемы, что делает код чистым и элегантным. при написании рекурсивной функции два точки необходимо серьезно рассмотреть. Это:

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

Фактическое значение любого данного числа обозначается как n! Оно может быть математически выражено следующим образом:

n! = n.(n-1).(n-2)…3.2.1

также вы можете сделать тэги (n-1).(n-2)…3.2.1 быть (n-1)! Таким образом, фактическое значение любого данного числа всегда n. (n-1)!

Теперь вы можете увидеть рекурсивное решение проблемы ниже.

object factorialDemo {
   def main(args: Array[String]) {
      for (i <- 1 to 5)
         println( "Factorial of " + i + ": = " + factorial(i) )
   }

   def factorial(n: Int): Int = {  
      if (n <= 1)
         return 1  
      else    
      return n * factorial(n - 1)
   }
}

Программа выдает результат следующим образом:
Factorial of 1: = 1
Factorial of 2: = 2
Factorial of 3: = 6
Factorial of 4: = 24
Factorial of 5: = 120

Вы можете увидеть выше, где есть объект с именем ‘factorialDemo’ и внутри него есть ‘main’ функция, содержащая цикл, который повторяется пять раз и также включает вызов ‘factorial’ ссылки на функцию, где рекурсивно вызывается функция, то есть n для пяти раз. Она останавливается на базовом случае, когда n становится меньше или равно 1, и результат возвращается и выводится.

Анонимная функция

Анонимная функция – это легкая запись функции, которая не имеет имени и известна как функциональный литерал в Scala.

Синтаксис с примером для анонимной функции:

  • Первый синтаксис и пример для анонимной функции:

Синтаксис:

('first_variable':'data_type', 'second_variable':'data_type') => "certain_expression"

Пример:

(var1:String:var2:String) => var1 + var2

Или

  • Второй синтаксис и пример для анонимной функции:

Синтаксис:

 (_:'data_type')operator(_'data_type')

Пример:

 (_:String)+(_:String)

Первый синтаксис показывает, что выражение после “=>” вычисляется до определенного значения, в то время как переменные перед “=>” используются для вычисления выражения.

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

Вы увидите пример анонимной функции ниже:

 object anonymousDemo  
{
    def main(args: Array[String])  
    {


        var function1 = (var1:Int, var2:Int) => var1 + var2
        var function2 = (_:Int) + (_:Int)

        // function call
        println(function1(5, 5))
        println(function2(7, 3))
    }
}

Initializing Scala interpreter ...



Spark Web UI available at http://DESKTOP-03TH7J0:4040
SparkContext available as 'sc' (version = 2.4.3, master = local[*], app id = local-1566986265958)
SparkSession available as 'spark'




<console>:10: error: unbound placeholder parameter

        var function2 = {_:Int} + {_:Int}

                         ^

<console>:10: error: unbound placeholder parameter

        var function2 = {_:Int} + {_:Int}

                                   ^

Программа, приведенная выше, дает выход, таков как:
10
10

Вы можете увидеть выше, что объект с именем ‘anonymousDemo’ содержит функцию ‘main’, содержащую два анонимные функции. Они синтаксически различны, но могут дать相同的结果, где ‘function’1 оценивается, принимая параметры из вызова функции, поскольку она вызывается – передавая значения 5 и 5, которые приводят к выводу 10, в то время как ‘function2’ также вызывается, передавая 7 и 3, где она получает значение раз и принимает любое допустимое ‘Integer’. В вашем случае, сделайте операцию addition и выведите результат.

Заключение

Поздравляем, вы прочитали этот учебник до конца.

В Scala есть много продвинутых тем, таких как higher-order functions, nested function, currying function и т.д.

Ссылки:
TOUR OF SCALA BASICS
Scala | Functions – Basics
Scala – Functions
Anonymous Functions in Scala

Посмотрите на курс DataCamp Introduction to Scala.

Source:
https://www.datacamp.com/tutorial/basic-functions-methods-scala