Scala pour la compréhension

Pour itérer à travers les collections dans les langages de programmation, nous utilisons les boucles comme la boucle pour. Un type de boucle unique appelé pour compréhension est introduit par le langage de programmation Scala. La construction, comme beaucoup d'autres à Scala, est un descendant direct de Haskell. Il peut être utilisé pour bien plus que de simplement faire du bouclage à travers les collections. Lors de l'utilisation d'un moyen de programmation fonctionnelle, il nous aide à gérer la complexité de la syntaxe.

Qu'est-ce que la compréhension dans Scala dans Ubuntu 20.04

Le format pour (énumérateurs) donne «e» dans les compréhensions où les énumérateurs sont une liste d'énumérateurs séparés par des demi-finales. Un générateur qui ajoute de nouvelles variables est un énumérateur, tandis qu'un filtre est un énumérateur. Chaque liaison créée par les énumérateurs est évaluée par une compréhension, qui publie ensuite une séquence de valeurs pour chaque valeur.

Syntaxe de la compréhension à Scala
Nous sommes dirigés par ces définitions vers les concepts de définitions, filtres et générateurs de compréhension. Une Scala à compréhension comprend les trois expressions suivantes:

pour
e <- elements // generator
n = D.Nom // Définition
if (expression) // filtre
rendement

Générateurs
Les générateurs sont comme des itérateurs qui itéèrent sur tous les éléments. Voici deux autres faits concernant les générateurs: (1) un générateur est la première étape de chaque compréhension, (2) plusieurs générateurs sont utilisés pour la compréhension.

Filtres
Les filtres prennent la forme de conditions booléennes à l'intérieur d'une compréhension. Un filtre sert de garde, empêchant toutes les valeurs d'être utilisées qui violent la condition booléenne. Chaque variable accessible dans le cadre de la compréhension peut être utilisée pour construire une condition booléenne personnalisée à l'intérieur d'un filtre.

Définitions
La définition est quelque chose que nous utilisons pour expliquer précisément ce que nous désirons accomplir ou faire. Par exemple, nous pouvons inclure toutes les opérations que nous souhaitons effectuer dans la partie déterminante.

Exemple 1: Utilisation de la compréhension avec des rendements

Pour construire une nouvelle collection à partir d'une collection existante, combinez la boucle pour votre algorithme et une déclaration de rendement. Une compréhension est l'application d'une boucle pour une déclaration de rendement. Mettez l'œuvre dans un bloc suivant le mot clé de rendement si votre approche nécessite de nombreuses lignes de code:

Nous avons créé l'objet comme «Demo1» où nous avons une définition de la fonction principale. À l'intérieur, nous avons construit la classe de cas «sujet». La classe a deux attributs: le «nom» défini sur le type de chaîne et «l'article» attribué au type «int». Après cela, nous avons déclaré une «base» variable qui a la représentation de la liste. La liste est initialisée avec le nom des trois sujets et numéros d'article, respectivement.

Ensuite, nous avons défini le générateur, la définition et le filtre à l'intérieur de la compréhension qui est définie dans la variable «MoreThanten». Dans la compréhension, le «sujet» a parcouru chaque élément à l'intérieur de la «base». Ensuite, nous avons une déclaration «IF» qui indique le filtre ici. La déclaration «si» qui a le «sujet.Article> = 10 && Sujet.article< 20 ” condition means that the article that doesn't seem to be between 10 and 20 is filtered away.

En dessous de la compréhension, nous avons utilisé le mot-clé «rendement» qui ajoute le sujet.nom. Depuis le sujet.Le nom est une chaîne, l'opérateur de rendement rassemble le résultat en tant que liste [chaîne].

Dans la sortie, vous pouvez visualiser la liste des noms de sujets générés comme supérieur à l'article numéro 10 et inférieur à l'article numéro 20.

Exemple 2: Utilisation de la compréhension sans rendements dans Scala

Nous pouvons laisser de côté le rendement en compréhension. Lorsque cela se produit, la compréhension rend une unité. Si nous voulons effectuer les effets secondaires, cela peut être utile. Voici un programme similaire qui n'utilise pas le rendement:

Nous avons commencé l'objet du programme comme «Demo2». En cela, nous avons la définition de la méthode principale. Dans la méthode principale, nous avons une autre définition de fonction. La fonction est définie comme «Vérifier» qui prend la variable «x» comme une entrée et la définit avec le type d'int. Nous avons attribué la compréhension à cette fonction. La compréhension à forte. Le générateur a l'itération par I et J.

Ensuite, la condition «i * j> = x» est réalisée ici si la condition est gardée en tant que filtre. Comme nous avons alloué la valeur de la variable «x» comme «5». Dans l'itération initiale, I et J sont tous deux nuls. Par conséquent, i * j n'est pas supérieur à x, et rien n'est ainsi cédé. Avant que je ne sois levé à 1, J est augmenté de trois fois. Les deux valeurs de i et j sur chaque itération jusqu'à ce que la condition soit satisfaite et imprimée par la méthode println.

Le compilateur Scala lors de la compilation produit les résultats suivants:

Exemple 3: Utilisation de la compréhension avec deux générateurs à Scala

Voici un autre cas où nous employons deux générateurs dans la «compréhension» mais avec le mot-clé de rendement.

Dans cet exemple, nous avons un «produit» de définition de fonction qui est développé pour calculer toutes les paires de nombres allant entre 0 et X-1 dont le produit correspond à une valeur spécifiée Y. Nous avons deux générateurs, I et J, qui augmentent de 1 jusqu'à X comme indiqué dans la compréhension. Nous utilisons ensuite le filtre comme nécessaire. Nous itérons dans la liste avec la boucle pour chaque boucle et destructure de chaque membre comme (i, j). Ensuite, sortez les accords.

Nous avons également créé la liste que la méthode a renvoyée sans aucun filtre pour afficher les étapes que les générateurs I et J prennent. Les résultats démontrent que si l'un des générateurs augmente par N-1, l'autre reste fixe. Le deuxième générateur augmente de 1 lorsque le premier atteint N-1.

Vous pouvez voir la sortie de la liste générée avec et sans le filtre dans la compréhension comme suit:

Conclusion

Les différentes capacités et fonctionnalités des compréhensions de Scala nous ont donc été informés via l'article susmentionné. À l'aide de plusieurs exemples, nous avons démontré les différents avantages de l'utilisation de la compréhension de Scala dans le modèle de programmation Scala. Après cela, nous avons appris les nombreuses capacités et le fonctionnement du rendement. En conséquence, nous pourrons désormais créer le code tout en utilisant la compréhension de Scala.