Principes de base des fonctions et méthodes en Scala

Tutoriels
Scala

Scala est-il un langage de programmation que vous souhaitez apprendre ? Prenez le cours de DataCamp Introduction à Scala.

Scala est un langage de programmation fonctionnel où il contient des fonctions comme des valeurs de première classe ainsi que des méthodes. Il présente des similitudes et des différences avec les autres langages. Les fonctions et les méthodes constituent une bloc de code réutilisable qui permet de stocker le code répété en un seul endroit, ce qui permet de les appeler pour exécuter une tâche spécifique. Elles facilitent également la débuggage et la modification du code.

Toutefois, les fonctions sont des objets qui sont initialisés dans des variables, tandis que les méthodes commencent par le mot-clé ‘def’ suivi du nom de la méthode, de la liste des paramètres et du corps de la méthode avec la valeur de retour.

Déclaration et définition de la méthode

La syntaxe pour la déclaration et la définition de la méthode en Scala est la suivante :

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

Une méthode en Scala commence avec les parties suivantes :

  1. ‘def’: le mot-clé utilisé pour déclarer les méthodes.
  2. ‘method_name’: le nom de votre méthode, écrite en lower camel case.
  3. ‘parameters’: les paramètres de la méthode peuvent être absents ou contenir un seul paramètre, mais plusieurs paramètres sont séparés par une virgule.
  4. ‘return_type_of_parameters’: il faut qu’il corresponde au type de données des ‘paramètres_list’ et est obligatoire.
  5. ‘type_de_retour_de_methode’: facultatif, mais par défaut, ‘Unité’ est retourné, mais la valeur peut être retournée avec le mot-clé ‘return’.
  6. Symbole_de_ affectation(‘=’) : facultatif, et si utilisé, il affectera la valeur de retour, tandis qu’il n’y aura pas de retour si non utilisé.
  7. ‘corps_de_methode’ : est le bloc de code entre guillemets ‘{}’ et consiste en la logique requise ou certaines tâches ou opérations.
  8. return : est le mot-clé utilisé pour retourner les valeurs requises et aussi pour terminer le programme, mais il est rarement utilisé en Scala.

Appel de méthode

La syntaxe pour l’appel de méthode en Scala est la suivante :

    method_name(arguments)

L’appel de méthode peut être effectué rapidement par ‘nom_de_methode’, qui est le nom de la méthode correspondante que vous souhaitez appeler en passant les arguments.

Une méthode avec des arguments nommés

La méthode avec des arguments nommés permet de passer l’argument au paramètre de la méthode lors de l’appel de la méthode, où chaque argument est correspondé à un paramètre de méthode à la suite. Vous verrez l’exemple ci-dessous de l’appel de méthode avec une déclaration et une définition de fonction ainsi que l’affichage en action :

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

Le programme ci-dessus donne la sortie suivante :
La différence de la valeur est : 2
La différence de la valeur est : 2

Le programme ci-dessus contient un objet ‘calculateResult’, et à l’intérieur, il contient une méthode nommée ‘funSub’ avec les paramètres x et y ayant un type de retour ‘Int’, le type de retour général de la méthode est ‘Int’. Il est suivi d’une instruction d’affectation pour assigner la valeur de retour. Les accolades indiquent le début du corps de la méthode, où la variable ‘diff’ est initialisée avec la valeur initiale de 0. L’appel de méthode ‘funSub(8,6)’ effectué dans la méthode principale correspond 8 à ‘x’ et 6 à ‘y’, et l’opération de soustraction est effectuée, et la valeur de ‘diff’ est retournée et finalement imprimée. De même, ‘funSub(x=8,y=6)’ correspond 6 à ‘y’ et 8 à ‘x’ aux paramètres de la méthode lors de l’appel de méthode où l’ordre n’a pas d’importance, une opération similaire est effectuée et est retournée et le résultat est imprimé.

Valeurs par défaut des paramètres

Vous pouvez spécifier les valeurs par défaut pour les paramètres de méthode en initialisant les valeurs correspondantes et pouvez laisser l’appel de méthode vide en ne passant pas d’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() );

   }
}

Le programme ci-dessus donne la sortie suivante :
La valeur finale est : 3

Vous pouvez voir que le programme ci-dessus contient une classe nommée ‘calculateResult’ et à l’intérieur, il y a une méthode nommée ‘funSub’ avec les paramètres x et y, les deux ayant un type de retour ‘Int’ et le type de retour global de la méthode est ‘Int’. Elle est suivie par une affectation qui assignera la valeur de retour. Les accolades indiquent le début du corps de la méthode où la variable ‘diff’ est initialisée à sa valeur initiale de 0. L’appel de méthode est effectué à l’intérieur de la méthode principale où ‘funSub()’ est appelée et initialise x à 9 et y à 6, et l’opération est effectuée, ce qui fait que la valeur de ‘diff’ est retournée et affichée.

Arguments de longueur variable

Les arguments de longueur variable sont les arguments qui acceptent un nombre variable d’arguments et peuvent être passés par l’utilisateur ou le client. Le dernier paramètre de la méthode est déclaré en utilisant ‘*’ qui doit être répété.

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

Le programme ci-dessus donne la sortie suivante :
Scala
est
great

Vous pouvez voir que le programme ci-dessus contient une classe ‘variableArgument’ avec une méthode ‘printAll’ où un argument de longueur variable ‘String*’ est défini à la fin et lors de l’appel de la méthode, une liste de chaînes de caractères peut être passée. La liste passée de chaînes de caractères est parcourue et affichée comme sortie à l’intérieur de la fonction principale.

Fonction de récurrence

La récursion est une technique utilisée en programmation fonctionnelle où le problème est résolu en le breakant progressivement en plus petits sous-problèmes, qui sont semblables au problème original. Plus les petits problèmes sont résolus, et plus leurs solutions sont appliquées pour obtenir les solutions du problème original. Donc, c’est appelé un problème de diviser-pour-dominer ou de diminuer-pour-dominer, ce qui rend le code propre et élégant. Lors de l’écriture d’une fonction récursive, deux points doivent être strictement considérés. Ils sont :

  • Cas de base : Il peut y avoir plus d’un cas de base dans une fonction qui doit être trouvé sinon peut mener à une récursion infinie. Il doit avoir une solution, c’est-à-dire la forme simple de sortie ou de solution qui peut être atteinte sans récursion.
  • Cas récursif : Le cas où la fonction récursive est appliquée, c’est-à-dire les appels récursifs sont effectués. La cuisse du problème est que dans chaque appel récursif, la taille doit diminuer, c’est-à-dire que le problème doit être divisé en sous-problèmes plus petits jusqu’à atteindre le cas de base. Enfin, vous combinez les solutions pour obtenir le problème principal, ce qui est appelée une approche de diviser-dominer.

Le facteuriel de n’importe quel nombre donné est n! Il peut être exprimé mathématiquement comme suit :

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

De plus, vous pouvez faire les termes (n-1).(n-2)…3.2.1 pour être (n-1)! Donc, le facteuriel de n’importe quel nombre donné est toujours n. (n-1)!

Maintenant, vous pouvez voir ci-dessous la manière récursive de résoudre le problème.

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

Le programme ci-dessus affiche la sortie suivante :
Factorial of 1: = 1
Factorial of 2: = 2
Factorial of 3: = 6
Factorial of 4: = 24
Factorial of 5: = 120

Vous pouvez voir ci-dessus où il y a un objet appelé ‘factorialDemo’ et à l’intérieur, il y a une fonction ‘main’ contenant une boucle qui se répète cinq fois et aussi une appel de fonction à ‘factorial’. La fonction récursive effectue une appel récursif, c’est-à-dire de n à cinq fois. Elle s’arrête au cas de base lorsque n devient inférieur ou égal à 1, et le résultat est retourné et affiché.

Fonction anonyme

Une fonction anonyme est une définition de fonction légère qui n’a pas de nom et est connue en Scala comme une expression de fonction.

La syntaxe avec un exemple pour une fonction anonyme est comme suit :

  • La première syntaxe et un exemple de fonction anonyme est :

Syntaxe :

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

Exemple :

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

OU

  • La deuxième syntaxe et un exemple de fonction anonyme est :

Syntaxe :

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

Exemple :

 (_:String)+(_:String)

La première syntaxe montre que l’expression après « => » est évaluée à une valeur particulière tandis que la liste des variables avant « => » est utilisée pour évaluer l’expression.

La deuxième syntaxe ci-dessus fonctionne comme un lieu de remplacement où elle accepte la valeur comme un caractère ‘joker’ uniquement une fois, et ensuite l’opérateur est effectué entre eux.

Vous verrez un exemple de fonction anonyme ci-dessous:

 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}

                                   ^

Le programme ci-dessus donne la sortie suivante :
10
10

Vous pouvez voir ci-dessus l’objet nommé ‘anonymousDemo’ avec la fonction ‘main’ contenant deux fonctions anonymes. Leur syntaxe est différente mais elles peuvent produire le même résultat, où ‘function’1 est évaluée en prenant les paramètres d’une appel de fonction au moment de l’appel – en passant les valeurs 5 et 5, ce qui résulte en une sortie imprimée à 10 tandis que ‘function2’ est également appelée en passant 7 et 3 où elle reçoit la valeur une fois, ce qui accepte n’importe quel ‘Integer’ valide. Dans votre cas, effectuez l’opération d’addition et affichez le résultat.

Conclusion

Félicitations, vous avez terminé ce tutoriel.

Il existe de nombreux sujets avancés en Scala tels que les fonctions de haut ordre, les fonctions imbriquées, les fonctions de curry, etc.

Référence :
TOUR DES BASIQUES DE SCALA
Scala | Fonctions – Bases
Scala – Fonctions
Fonctions Anonymes en Scala

Consultez le cours Introduction à Scala de DataCamp.

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