Scala sort de la boucle
Exemple # 01
Nous commençons notre article avec l'exemple le plus élémentaire de Scala pour discuter de l'utilisation des fonctions de rupture dans les boucles. Nous devons utiliser un fichier contenant l'extension Scala à sa fin pour éviter tout problème dans un avenir proche. Nous avons créé le «test.Fichier Scala »et l'a utilisé avec succès dans l'éditeur de texte.
Premièrement, nous importons le scala.user.Le package de contrôle ici pour utiliser en douceur les ruptures du code. Après cela, nous avons initialisé un «test» d'objet à utiliser pour l'exécution. Nous avons initialisé la variable «n» avec valeur 0 et répertorier la variable «L» avec un total de 8 éléments entiers. Un autre objet variable, «B» a appelé la classe «Breaks» pour utiliser la fonction Break () dans les boucles. L'objet «B» serait utilisé pour appeler la fonction cassable avant les boucles pour éviter toute erreur dans l'exécution.
Dans cette fonction cassable, nous avons créé une boucle «pour» itérant en utilisant chaque valeur de la liste «L» dans la variable «n». L'instruction println () à l'intérieur serait utilisée pour afficher le numéro d'itération, i.e., la valeur d'une liste. Parallèlement à cela, nous avons utilisé la déclaration «IF» pour définir une condition pour briser la boucle. Si la variable d'itération de boucle «n» répond à la valeur «9», elle appellera l'instruction BREAK avec l'objet de classe Break «B». La boucle sera brisée en ce moment, et nous serons hors de la boucle exécutant le reste du code. La dernière instruction de fonction println () afficherait que nous sommes hors de la boucle, le cassant avec succès.
Enregistrons d'abord cet exemple le plus simple exemple de ce guide via la touche Ctrl + S simple et ouvrez le shell à des fins de compilation. Après avoir enregistré le fichier Scala, nous l'avons compilé avec le compilateur «Scalac» de Scala. Le fichier d'objet «test» a été créé au même endroit. Nous avons exécuté le code compilé en utilisant le nom d'un «test» d'objet utilisé dans le code. La sortie est présentée sur notre écran de console. La boucle a été itérée et les 5 premières valeurs impaises ont été imprimées, tandis que lorsque la boucle rencontre la valeur 9, elle se casse. Le dernier message d'impression a été affiché.
Exemple # 02
Nous avons discuté de l'utilisation des pauses sur une seule boucle lors de la programmation dans le langage Scala. Les boucles uniques ne sont pas autant les fabricants de troubles que les boucles imbriquées. Donc, dans cet exemple maintenant, nous briserons les boucles imbriquées en utilisant la même scala.user.Package de contrôle de Scala. Par conséquent, le démarrage du nouveau programme dans le même fichier scala. Nous devons démarrer le code avec le mot-clé d'importation utilisé pour l'importation du «Scala.user.Contrôle »Bibliothèque. Le «test» de l'objet a été démarré avec la définition de la fonction principale ().
Nous avons initialisé deux variables, «N» et «M» avec la valeur «0». Ensuite, nous avons initialisé deux listes distinctes, L1 et L2, en utilisant la fonction List (). La première liste contient 3 valeurs entières tandis que l'autre contient 5 valeurs entières. Deux autres variables, «out» et «in» sont initialisées en utilisant la classe Breaks de Scala. Ces deux variables sont utilisées comme objets de rupture à utiliser pour briser les boucles. L'objet «Out» serait utilisé pour la boucle extérieure, et l'objet «in» serait utilisé pour la pause en boucle intérieure.
Ainsi, nous avons appelé la fonction cassable avec l'objet variable «Out» pour éviter toute exception dans la boucle extérieure de ce programme Scala. Dans cette fonction cassable, nous avons initialisé une boucle «pour» imbriquée. La boucle extérieure a pris des valeurs de la première liste «L1» dans une variable «n» pour son itération. L'instruction println () dans la boucle extérieure a été utilisée pour afficher la valeur de la variable «n» i.e., chaque élément de liste. Maintenant, nous avons appelé à nouveau la fonction cassable () avec l'objet variable «in» pour éviter les exceptions de boucle intérieure et indiquer clairement que nous allons utiliser la boucle intérieure maintenant.
La boucle intérieure «pour» s'est itérée en utilisant les valeurs de la deuxième liste «L2» dans la variable «M». Sa déclaration println () afficherait chacune de ses valeurs de liste ou les numéros d'itération l'un après l'autre. Il contient également une déclaration «IF» pour définir une condition dans la boucle intérieure pour briser cette boucle imbriquée (boucle dans une boucle). Si la valeur de l'itérateur variable «M» atteint 8, la boucle intérieure sera brisée par l'objet variable «in» en utilisant l'instruction de fonction de rupture de Scala. La boucle intérieure se casse à chaque fois qu'il atteint 8 jusqu'à ce que la boucle extérieure termine toutes ses itérations. Économions et exécutons ce code pour le moment.
En compilation et en exécution du code Scala, nous avons la sortie longue à l'écran de la console. La boucle extérieure est terminée avec succès, tandis que la boucle intérieure se casse à chaque fois qu'elle rencontre 8.
Conclusion
Dans le cadre de l'introduction de notre article, nous avons discuté de la nécessité d'utiliser des déclarations de pause des fonctions dans les langages de programmation de nos jours. Pour cela, nous avons discuté de l'utilisation de Scala.user.Package de contrôle avec ses fonctions de rupture, je.e., Déclaration de casque et de rupture. Nous avons discuté de l'utilisation des déclarations de pause pour briser les boucles simples et imbriquées à Scala.