Introdução aos Funções e Métodos em Scala

Tutoriais
Scala

Interessado em aprender mais sobre Scala? Prima o curso de Introdução a Scala no DataCamp.

Scala é uma linguagem de programação funcional que contém ambas as funções como valores de primeira classe e métodos e tem similaridades e diferenças. Tanto as funções quanto os métodos são um bloco de código reutilizável que também é usado para armazenar o código repetido em um só lugar, o que faz com que uma chamada de função realize uma tarefa específica particular. Eles também tornam o código mais fácil de debugar e modificar.

No entanto, as funções são um objeto que é inicializado em uma variável, mas os métodos começam com a palavra-chave ‘def’ seguida do nome do método, da lista de parâmetros, do corpo do método com o valor de retorno.

Declaração e Definição de Método

A sintaxe para declaração e definição de método em Scala está abaixo:

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

O método em Scala começa com as seguintes partes:

  1. ‘def’: palavra-chave usada para declarar métodos.
  2. ‘method_name’: é o nome do seu método, que está em lower camel case.
  3. ‘parameters’: são parâmetros de método que podem ter nenhum parâmetro ou apenas um parâmetro, mas são separados por vírgula quando houver mais de um parâmetro.
  4. ‘return_type_of_parameters’: precisa corresponder de acordo com o tipo de dado de ‘parameters_list’ e é obrigatório.
  5. ‘tipo_de_retorno_do_método’: é opcional, mas por padrão, ‘Unit’ é retornado, mas o valor pode ser retornado com a palavra-chave ‘return’.
  6. Símbolo de Atribuição(‘=’): é opcional, e se usado, atribuirá o valor de retorno e não usando ele fará com que o método não retorne nada.
  7. ‘corpo_do_método’: é o bloco de código delimitado por chaves ‘{}’ e consiste na lógica necessária ou em uma tarefa ou operações específicas.
  8. return: é a palavra-chave usada para retornar os valores necessários e também para encerrar o programa, mas raramente é usada em Scala.

Chamada de Método

A sintaxe para a chamada de método em Scala é a seguinte:

    method_name(arguments)

A chamada de método pode ser feita rapidamente por ‘nome_do_método’, que é o nome do método correspondente que você deseja chamar com os argumentos passados.

Um Método com Argumentos Nomeados

O método com argumentos nomeados permite passar o argumento para os parâmetros do método durante a chamada do método, onde cada argumento é correspondido um a um aos parâmetros do método. Você verá o exemplo abaixo de passar os argumentos com a declaração e definição de função, juntamente com a chamada de método em ação:

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));
   }
}

O programa acima produz a saída como:
Diferença entre os valores é: 2
Diferença entre os valores é: 2

O programa acima contém um objeto ‘calculateResult’, e dentro dele contém um método chamado ‘funSub’ com ambos os parâmetros x e y tendo o tipo de retorno como ‘Int’, o tipo de retorno global do método é ‘Int’. Ele é seguido por uma declaração de atribuição para atribuir o valor de retorno. As chaves representam o início do corpo do método, onde a variável ‘diff’ é inicializada com o valor inicial de 0. A chamada de método ‘funSub(8,6)’ feita no método principal corresponde a 8 com ‘x’ e 6 com ‘y’, e a operação de subtração é executada, o valor de ‘diff’ é retornado e finalmente impresso. Similarmente, a ‘funSub(x=8,y=6)’ corresponde a 6 com ‘y’ e 8 com ‘x’ aos parâmetros no método durante a chamada de método onde a ordem não importa e onde uma operação semelhante é feita e retornado e o resultado é impresso.

Valores Padrão de Parâmetro

Você pode especificar valores padrão para os parâmetros do método através da inicialização dos valores correspondentes e pode deixar a chamada de método vazia, não passando o argumento.

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() );

   }
}

O programa acima dá o seguinte output:
O valor final é: 3

Você pode ver que o programa acima contém um objeto definido como ‘calculateResult’ e dentro disso há um método chamado ‘funSub’ com os parâmetros x e y, ambos com o tipo de retorno ‘Int’ e o tipo de retorno global do método é ‘Int’. Ao lado há uma instrução de atribuição que atribuirá o valor de retorno. As chaves {} indicam o início do corpo do método, onde a variável ‘diff’ é inicializada com o valor inicial de 0. A chamada de método é feita dentro do método principal onde ‘funSub()’ é chamado e inicializa x com 9 e y com 6, a operação é executada, fazendo com que o valor ‘diff’ seja retornado e impresso.

Argumentos de Tamanho Variável

Argumentos de tamanho variável são os argumentos que podem assumir um número variável de argumentos e podem ser passados pelo usuário ou cliente. O último parâmetro do método é declarado usando ‘*’, que precisa ser repetido.

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;
      }
    }
}

O programa acima dá o seguinte resultado:
Scala
é
grande

Você pode ver que o programa acima contém um objeto ‘variableArgument’ com o método ‘printAll’ onde o argumento de tamanho variável ‘String*’ é definido no final e durante a chamada do método, uma lista de strings pode ser passada. A lista passada de strings é percorrida e mostrada como saída dentro do método principal.

Função de Recursão

Recursão é a técnica usada na programação funcional onde o problema é resolvido através da quebra recorrente em subproblemas menores, que são semelhantes ao problema original. Os problemas menores são resolvidos, e suas soluções são aplicadas para obter as soluções para o problema original. Portanto, é chamado de um problema de divisão-e-conquista ou diminuição-e-conquista, o que torna o código limpo e elegante. Ao escrever uma função recursiva, dois pontos precisam ser considerados estritamente. Eles são:

  • Caso base: Pode haver mais de um caso base em uma função que precisa ser descoberto, caso contrário, pode levar à recursão infinita. Precisa ter uma solução, ou seja, a forma simples de saída ou solução que pode ser alcançada sem recursão.
  • Caso recursivo: O caso onde a função recursiva é aplicada, ou seja, as chamadas recursivas estão sendo feitas. O núcleo do problema é que em cada chamada recursiva, o tamanho precisa diminuir, ou seja, o problema precisa ser dividido em subproblemas menores até que você chegue ao caso base. Por último, você combina as soluções para obter o problema principal, o que é chamado de abordagem de divisão e conquista.

O fatorial de qualquer número dado é n! Ele pode ser expresso matematicamente da seguinte forma:

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

Também, você pode fazer os termos (n-1).(n-2)…3.2.1 serem (n-1)! Então, o fatorial de qualquer número dado é sempre n. (n-1)!

Agora você pode ver abaixo a forma recursiva de resolver o problema.

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)
   }
}

O programa acima produz a saída como:
Fatorial de 1: = 1
Fatorial de 2: = 2
Fatorial de 3: = 6
Fatorial de 4: = 24
Fatorial de 5: = 120

Você pode ver acima onde há um objeto chamado ‘factorialDemo’ e dentro dele, há uma função ‘main’ que contém um loop que se repete cinco vezes e também inclui uma chamada de função para ‘factorial’ onde a função recursiva faz uma chamada recursiva, ou seja, n vezes cinco. Ele para no caso base quando n se torna menor ou igual a 1, e o resultado é retornado e impresso.

Função Anônima

Uma Função Anônima é uma definição de função leve que não tem nome e é conhecida como função literal em Scala.

A sintaxe e exemplo para Função Anônima são como segue:

  • A primeira sintaxe e um exemplo para função anônima é:

Sintaxe:

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

Exemplo:

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

OU

  • A segunda sintaxe e um exemplo para função anônima é:

Sintaxe:

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

Exemplo:

 (_:String)+(_:String)

A primeira sintaxe mostra que a expressão após “=>” avalia para um valor específico, enquanto uma lista de variáveis antes de “=>” é usada para avaliar a expressão.

A segunda sintaxe acima funciona como um espaço reservado, aceitando o valor como um caractere ‘wild card’ apenas uma vez, e então o operador é operado entre eles.

Você verá um exemplo de função anônima abaixo:

 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}

                                   ^

O programa acima produz a saída:
10
10

Você pode ver acima o objeto chamado ‘anonymousDemo’ com a função ‘main’ contendo duas funções anônimas. Eles são sintaticamente diferentes, mas podem produzir o mesmo resultado, onde ‘function’1 é avaliado pegando parâmetros de uma chamada de função conforme está sendo chamado—passando os valores 5 e 5, o que resulta na saída impressa como 10, enquanto ‘function2’ também é chamada passando 7 e 3, onde recebe o valor uma vez, aceitando qualquer ‘Integer’ válido. No seu caso, faça a operação de adição e mostre o resultado.

Conclusão

Parabéns, você acabou de ler este tutorial.

Existem muitos tópicos avançados em Scala, como funções de ordem superior, funções aninhadas, funções de currying, etc.

Referências:
TOUR DOS CONCEITOS BÁSICOS DE SCALA
Scala | Funções – Básico
Scala – Funções
Funções Anônimas em Scala

Confira o curso da DataCamp Introdução ao Scala.

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