Scala Fonctions d'ordre supérieur

Lorsqu'une fonction accepte une autre fonction comme un paramètre ou renvoie une autre fonction comme une sortie, elle est appelée fonction d'ordre supérieur. Cela fait référence aux fonctions qui interagissent avec d'autres fonctions. Il est important de noter que cette fonction d'ordre supérieur peut être utilisée avec des fonctions et des méthodes qui renvoient les fonctions comme résultats ou prennent les fonctions comme paramètres. Ceci est possible car le compilateur Scala permet la conversion des méthodes en fonctions. L'idée des fonctions d'ordre supérieur dans Scala dans Ubuntu 20.04 est expliqué dans cet article.

Importance des fonctions d'ordre supérieur

En ce qui concerne les fonctions d'ordre supérieur, certains points clés comprennent:

• • Les fonctions d'ordre supérieur sont concevables car le langage de programmation Scala traite les fonctions comme des valeurs de première classe. Cela signifie que, comme d'autres valeurs, les fonctions peuvent être fournies comme paramètres ou sorties, ce qui est utile pour fournir un moyen flexible d'écrire les programmes.
  • Lors de la construction d'une composition de fonction où les fonctions peuvent être créées à partir d'autres fonctions, il est avantageux. La méthode de composition connue sous le nom de «composition de fonction» consiste à utiliser deux fonctions précédemment composées pour créer une seule fonction.
  • Les fonctions lambda et les fonctions anonymes peuvent également être créées avec son aide. Les fonctions sans nom mais néanmoins la fonction comme fonctions sont connues sous le nom de fonctions anonymes.
  • Il est appliqué aux programmes ainsi que la réduction du nombre de lignes de code inutiles.

Exemple 1: Utilisation d'une fonction pour prendre une autre fonction comme un argument

Considérons le premier exemple d'une fonction d'ordre supérieur. Nous passons la fonction dans une fonction donnée en tant que paramètre.

Ici, l'objet est désigné comme «MyObject». Ensuite, dans la définition principale de l'objet, nous avons appelé une fonction «Func». La fonction «func» prend la valeur numérique et la fonction «MultiplyByre» comme entrée. Nous avons de nouveau invoqué la fonction «Func» pour imprimer la valeur de «X» qui est transmise comme une entrée à l'intérieur du «F». Enfin, nous définissons l'opération «x * 3» dans la fonction «MultiplyByre».

Au fur et à mesure que nous passions, la fonction «MultiplyByre» à l'intérieur de l'autre fonction «Func», la fonction «Func» obtient le résultat de la fonction «MultiplybyThe» comme suit:

Exemple 2: Utilisation de la fonction anonyme comme Lambda

Une fonction anonyme n'a pas de nom mais remplit la même fonction. Lorsque vous n'avez pas l'intention de répéter une fonction plus tard, créer une version anonyme est une bonne idée. À Scala, la fusée des opérateurs de jokers «=>» et le soulignement «_» peuvent être utilisés pour générer des fonctions anonymes.
En voici un pour illustrer:

Dans la méthode principale de l'objet «Mydemo», nous avons créé deux variables. Les variables sont déclarées «RES1» et «RES2». La variable «Res1» est initialisée avec la fonction anonyme en utilisant l'opérateur «=>». La fonction anonyme est définie avec les paramètres x et y et sur le côté droit de l'opérateur de fusée «=>», nous définissons l'équation «x + y». Après cela, nous avons une autre fonction anonyme qui est employée avec le joker «_». Dans la méthode println, nous avons appelé respectivement les «res1» et «res2» et leur avons attribué deux valeurs.

Les résultats pour les deux fonctions anonymes sont générés comme suit:

Exemple 3: Utilisation de l'expression multiligne

Le terme «expression multiline» fait référence aux expressions qui s'étendent sur de nombreuses lignes. Lorsque vous utilisez les expressions multilines à Scala, utilisez la prudence. Pour éviter les problèmes concernant l'expression multiligne, vous pouvez utiliser les méthodes suivantes:

L'objet «MyTest» a la définition de trois fonctions. La première fonction est définie comme «SUM1» qui prend les paramètres «I» et «J». Les valeurs d'entrée «i» et «j» sont définies comme «i + j» dans le bloc fonction «SUM1». Ensuite, nous avons une autre fonction comme «SUM2» qui prend également les valeurs d'entrée et définit également l'opération «I + J». Après cela, nous avons défini la méthode principale où deux variables «result1» et «result2» sont déclarées. Ces variables sont appelées les fonctions «SUM1» et «SUM2» pour transmettre les valeurs contre «I» et «J».

La sortie obtenue par les deux fonctions «SUM1» et «SUM2» ont les mêmes résultats.

Exemple 4: Utilisation d'une fonction transportant

Une méthode à Scala peut avoir de nombreuses listes de paramètres. Une fonction qui accepte les listes d'arguments manquantes comme des arguments est produite lorsqu'une fonction est appelée avec moins de listes de paramètres qu'elle ne nécessite. En d'autres termes, c'est une méthode pour modifier une fonction qui accepte plusieurs paramètres en un seul qui n'accepte qu'un.

Ici, nous avons créé une fonction «ajouter» qui prend deux arguments séparément. Le «P» est le premier argument et «Q» est le deuxième argument. Ensuite, nous avons déclaré une variable «Result1» dans la méthode principale. La variable «Result1» est appelée fonction «Add» et définit les valeurs pour «p» et «q». De plus, nous avons transmis l'argument unique pour la fonction «Add» qui est appelée dans la variable «addvalues». Les addvalues ​​prennent également les valeurs d'argument d'un nombre.

Les résultats du code précédent lors de la compilation sont les suivants:

Exemple 5: Utilisation d'une fonction imbriquée

Étant un langage de fonction de première classe, Scala vous permet de passer les fonctions, de renvoyer les fonctions, de composer les fonctions, d'utiliser les fonctions imbriquées et plus. La définition et l'appel des fonctions imbriquées sont démontrées dans l'exemple suivant:

Dans la fonction «sub1», nous avons défini une autre fonction «sub2» qui évalue la différence entre «A-B». En dehors de la fonction Sub2, nous avons appelé le «sub2» qui prend la valeur de l'argument «x» et le «sub2 (y, z)». Ensuite, nous avons déclaré un «résultat» variable qui est appelé la fonction Sub1 et passé la valeur numérique à évaluer pour une opération différente.

Ce qui suit est le résultat opérationnel différent généré par le code précédent:

Exemple 6: Utilisation d'une fonction avec des paramètres de longueur variable

Vous pouvez définir les fonctions avec des paramètres de longueur variable dans Scala. Toute quantité d'arguments peut être adoptée lors de l'appel de la fonction.

À la fonction «Ajouter», nous définissons la variable «Mysum» qui est initialement nulle. Ensuite, nous avons pour Loop qui itère sur les nombres et les incréments par le mysum. À l'intérieur de la principale, nous avons appelé la fonction ADD et y passer les valeurs numériques.

La longueur de la variable «Mysum» est imprimée à l'écran.

Conclusion

Nous avons découvert à partir de l'article susmentionné que l'utilisation des fonctions d'ordre supérieur à Scala peut rendre la base de code simple et facile à comprendre pour les opérations. Les fonctions d'ordre supérieur sont celles qui acceptent ou renvoient les entrées d'autres fonctions. Nous avons également examiné les exemples démontrant les différentes applications de ces fonctions d'ordre supérieur. De plus, nous avons appris à remettre les fonctions anonymes comme des fonctions d'ordre élevé.