Basicos de funciones y métodos en Scala

Tutoriales
Scala

¿Está interesado en aprender más sobre Scala? Tomé el curso de Introducción a Scala de DataCamp.

Scala es un lenguaje de programación funcional que contiene tanto funciones como primeros valores de clase y métodos, y tiene similitudes y diferencias ambos. Tanto las funciones como los métodos son un bloque de código reutilizable que también se utiliza para almacenar el código repetido en un solo lugar, lo que hace una llamada a función para realizar una tarea específica particular. También hacen que el código sea más fácil de depurar y modificar.

Sin embargo, las funciones son un objeto que se inicializa en una variable, pero los métodos empiezan con la palabra clave ‘def’ seguida del nombre del método, la lista de parámetros, el cuerpo del método con el valor de retorno.

Declaración y definición de métodos

La sintaxis para la declaración y definición de métodos en Scala es la siguiente:

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

El método en Scala comienza con las siguientes partes:

  1. ‘def’: palabra clave que se utiliza para declarar métodos.
  2. ‘method_name’: es el nombre de su método, que está en minúsculas y camelCase.
  3. ‘parameters’: son los parámetros del método que pueden tener ningún parámetro o un solo parámetro, pero se separan por comas cuando hay más de un parámetro.
  4. ‘return_type_of_parameters’: debe coincidir según el tipo de datos de ‘parameters_list’ y es obligatorio.
  5. ‘return_type_of_method’: es opcional, pero por defecto se devuelve ‘Unit’, sin embargo, se puede devolver el valor con la palabra clave ‘return’.
  6. Símbolo de asignación (‘=’): es opcional, y si se utiliza asignará el valor de retorno; si no se utiliza, el método no devolverá nada.
  7. ‘method_body’: es el bloque de código rodeado de llaves ‘{}’ y consta de la lógica requerida o una determinada tarea o operaciones.
  8. return: es la palabra clave utilizada para devolver los valores requeridos y también para finalizar el programa, pero se utiliza raramente en Scala.

Llamada de método

La sintaxis para las llamadas de método en Scala es la siguiente:

    method_name(arguments)

La llamada de método se puede realizar rápidamente mediante ‘method_name’, que es el nombre del método correspondiente que se desea llamar pasando los argumentos.

Un método con argumentos nombrados

El método con argumentos nombrados permite pasar los argumentos a los parámetros del método durante la llamada de método, donde cada argumento se empareja uno a uno con los parámetros del método. Verás el ejemplo de abajo donde se pasan los argumentos con declaración y definición de función junto con la llamada de método en acción:

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

El programa anterior da como resultado:
Diferencia del valor es: 2
Diferencia del valor es: 2

El texto proporcionado contiene un objeto ‘calculateResult’, y dentro de él un método denominado ‘funSub’ con ambos parámetros x e y teniendo el tipo de retorno ‘Int’, el tipo de retorno general del método es ‘Int’. A esto le sigue una declaración de asignación para asignar el valor de retorno. Las llaves indican el comienzo del cuerpo del método, donde la variable ‘diff’ se inicializa con el valor inicial de 0. La llamada al método ‘funSub(8,6)’ realizada en el método main coincide 8 con ‘x’ y 6 con ‘y’, y se lleva a cabo la operación de substracción, se devuelve el valor de ‘diff’ y finalmente se imprime. Similarmente, ‘funSub(x=8,y=6)’ coincide 6 con ‘y’ y 8 con ‘x’ en los parámetros del método durante la llamada al método, donde no importa el orden, se realiza una operación similar y se devuelve el resultado que se imprime.

Valores de Parámetros Predeterminados

Puede especificar los valores predeterminados para los parámetros del método mediante la inicialización de los valores correspondientes y puede dejar la llamada al método vacía al no pasar el 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() );

   }
}

El programa anterior da como salida:
El valor final es: 3

Puede ver que el programa de arriba contiene un objeto definido como ‘calculateResult’ y dentro de él hay un método denominado ‘funSub’ con los parámetros x e y, ambos con tipo de retorno ‘Int’, y el tipo de retorno general del método es ‘Int’ y está seguido de una instrucción de asignación que asignará el valor de retorno. Las llaves indican el comienzo del cuerpo del método, donde la variable ‘diff’ se inicializa con el valor inicial de 0. La llamada al método se realiza dentro de método principal, donde ‘funSub()’ es llamado e inicializa x a 9 y y a 6, y se realiza la operación, lo que hace que el valor ‘diff’ sea retornado e impreso.

Argumentos de Longitud Variable

Los Argumentos de Longitud Variable son aquellos que toman cualquier número variable de argumentos y pueden ser pasados por el usuario o cliente. El último parámetro en el método se declara usando ‘*’ que necesita 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;
      }
    }
}

El programa de arriba da la salida como:
Scala
es
genial

Puede ver que el programa de arriba contiene un objeto ‘variableArgument’ con métodos ‘printAll’ donde el argumento de longitud variable ‘String*’ está definido al final y durante la llamada al método se puede pasar una lista de cadenas. La lista de cadenas pasada se recorre y se muestra como salida dentro de la función primaria.

Función de Recursión

La recursión es la técnica utilizada en programación funcional donde se resuelve el problema rompiéndolo repetidamente en subproblemas más pequeños, que son similares al problema original. Cuanto más pequeños se resuelven los problemas, y se aplican sus soluciones para obtener las soluciones del problema original. Así que se llama un enfoque división-y-conquista o decrecimiento-y-conquista, lo que hace que el código sea limpio y elegante. Cuando se escribe una función recursiva, hay dos puntos que se deben considerar estrictamente. Son:

  • Caso base: Puede haber más de un caso base en una función que necesita identificar de lo contrario podría llevar a una recursión infinita. Debe tener una solución, es decir, la forma simple de salida o solución que se puede lograr sin recursión.
  • Caso recursivo: El caso en el que se aplica la función recursiva, es decir, se están haciendo llamadas recursivas. La verdadera esencia del problema es que en cada llamada recursiva, la dimensión necesita disminuir, es decir, el problema debe dividirse en subproblemas más pequeños hasta que alcance el caso base. Finalmente, combinas las soluciones para obtener el problema principal, lo que se denomina enfoque división-y-conquista.

El factorial de cualquier número dado es n! Se puede expresar matemáticamente de la siguiente manera:

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

También puedes hacer que los términos (n-1).(n-2)…3.2.1 sean (n-1)! Así, el factorial de cualquier número dado es siempre n.(n-1)!

Ahora puedes ver debajo la forma recursiva de resolver el 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)
   }
}

El programa anterior proporciona la salida como:
Factorial de 1: = 1
Factorial de 2: = 2
Factorial de 3: = 6
Factorial de 4: = 24
Factorial de 5: = 120

Puede ver arriba donde hay un objeto llamado ‘factorialDemo’ y dentro de él, hay una función ‘main’ que contiene un bucle que se repite cinco veces y también incluye una llamada a función ‘factorial’ donde la función recursiva hace una llamada recursiva, es decir, n veces a cinco. Se detiene en el caso base cuando n se reduce a menos o igual a 1, y se devuelve y imprime el resultado.

Función Anónima

Una función anónima es una definición de función ligera que no tiene un nombre y se conoce como expresión función en Scala.

La sintaxis con ejemplo para la función anónima es la siguiente:

  • La primera sintaxis y un ejemplo de función anónima es:

Sintaxis:

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

Ejemplo:

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

O

  • La segunda sintaxis y un ejemplo de función anónima es:

Sintaxis:

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

Ejemplo:

 (_:String)+(_:String)

La primera sintaxis muestra que la expresión después de “=>” se evalúa a un valor particular, mientras que una lista de variables antes de “=>” se utiliza para evaluar la expresión.

La segunda sintaxis anterior funciona como un marcador de posición que acepta el valor como un carácter ‘comodín’ solo una vez, y luego se opera entre ellos el operador.

A continuación verá un ejemplo de función anónima:

 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}

                                   ^

El programa anterior da como resultado:
10
10

Puede ver arriba que el objeto se llama ‘anonymousDemo’ con la función ‘main’ que contiene dos funciones anónimas. Son diferentes sintácticamente pero pueden producir el mismo resultado, donde ‘function’1 se evalúa tomando parámetros de una función como está siendo llamada – pasando los valores 5 y 5, que resulta en un salto de salida impreso como 10 mientras que ‘function2’ también se llama pasando 7 y 3 donde recibe el valor una vez, que acepta cualquier valor ‘Integer’ válido. En su caso, realice la operación de suma y muestre el resultado.

Conclusión

Felicitaciones, ha terminado de leer este tutorial.

Hay muchos temas avanzados en Scala, como funciones de orden superior, funciones anidadas, funciones currying, entre otras.

Referencia:
TOUR OF SCALA BASICS
Scala | Functions – Basics
Scala – Functions
Anonymous Functions in Scala

Eche un vistazo al curso de DataCamp Introduction to Scala.

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