[JAVA] J'ai touché Scala ~ [Syntaxe de contrôle] ~
Introduction
Il s'agit d'une migration directe du didacticiel dwango, où vous allez l'étudier, le modifier et le remplacer par vos propres termes.
Puisque ce texte concerne l'apprentissage des bases de Scala, il y aura souvent des explications sur certaines syntaxes de Scala à partir de maintenant. Voici une brève description de la notation pour représenter la syntaxe. Dans cette section, vous découvrirez la syntaxe de contrôle de Scala. Ne vous inquiétez pas, ce n'est pas si farfelu que les langages de programmation classiques.
À propos de la notation
Puisque ce texte concerne l'apprentissage des bases de Scala, il y aura souvent des explications sur certaines syntaxes de Scala à partir de maintenant. Voici une brève description de la notation pour représenter la syntaxe.
Disposition des alphabets, etc.
Tout d'abord, comme indiqué ci-dessous, lorsqu'une séquence d'alphabets et de symboles apparaît telle quelle, elle représente la chaîne de caractères elle-même. Ici, il représente la chaîne si elle-même.
if
Une séquence d'alphabets, etc. entre guillemets
Ensuite, traitez la séquence d'alphabets et de symboles entre guillemets de la même manière. Ceci est utilisé pour éviter toute confusion avec certains caractères car ils ont une signification particulière, comme décrit ci-dessous. Ce qui suit a la même signification que précédemment.
'if'
Éléments inclus dans (et)
Un élément, entre (), représente un regroupement. Ce qui suit n'est pas une chaîne commençant par (, mais un groupe de caractères appelé if (). Ceci est utilisé pour regrouper les expressions répétées décrites plus loin.
('if' '(' ')')
Le regroupement a la priorité sauf s'il est explicitement indiqué comme «(» ou «)».
Éléments entre
Les noms entre
if '(' <Expression conditionnelle> ')'
Un élément suivi de *
Tout élément suivi de * est ajouté pour signifier que l'élément apparaît zéro fois ou plus. Ce qui suit signifie qu'un élément tel que; après
(<formule> ;)*
Ici, il est ambigu de savoir si a * est le caractère * après a ou si a est répété 0 ou plusieurs fois. Pour résoudre l'ambiguïté, l'itération prévaudra à moins qu'elle ne soit explicitement marquée d'un «*».
Un élément suivi d'un +
Tout élément suivi d'un + signifie que l'élément apparaît plus d'une fois. Ce qui suit signifie qu'un élément tel que; après
(<formule> ;)+
Ici, il est ambigu de savoir si a + est suivi de la lettre + ou si a est répété une ou plusieurs fois. Pour résoudre l'ambiguïté, l'itération doit prévaloir à moins qu'elle ne soit explicitement indiquée par «+».
Un élément suivi de?
Tout élément suivi d'un? Signifie que l'élément apparaît 0 ou 1 fois. En d'autres termes, cet élément est facultatif. Ce qui suit est
Cela signifie qu'un élément qui commence par else et est suivi par
(else <formule>)?
Ici, il est ambigu de savoir si a? Est suivi du caractère?, Ou s'il s'agit d'une occurrence 0 ou 1 de a. Pour résoudre l'ambiguïté, l'option prévaudra à moins qu'elle ne soit explicitement indiquée par «?».
| Ajouté entre deux éléments
Deux éléments A et B avec un | ajouté signifient que A ou B est acceptable. Ce qui suit signifie que val ou var peut être utilisé.
('val'|'var')
Où un|b est un|Il est ambigu que ce soit les trois lettres b ou a ou b. Explicitement pour résoudre l'ambiguïté'|'Sauf si l'interprétation a ou b prévaut.
Un élément suivi de ...
Il est utilisé pour illustrer les premiers éléments lorsqu'un certain nombre d'éléments viennent, et pour indiquer clairement que le reste apparaîtra dans le même modèle. Ce qui suit représente un modèle qui est entouré de [et] et a un nombre arbitraire d'expressions.
'[' <Équation 1>, <Équation 2>, ... ']'
si la syntaxe de l'expression
Sur la base de ce qui précède, la syntaxe de l'expression if de Scala est la suivante.
if '(' <Expression conditionnelle> ')' <formule> ( else <formule> )?
Nous parlerons plus tard des expressions if de Scala.
Syntaxe de contrôle
Dans cette section, vous découvrirez la syntaxe de contrôle de Scala. Ne vous inquiétez pas, ce n'est pas si farfelu que les langages de programmation classiques.
À propos des termes «syntaxe», «expression» et «instruction» Dans cette section, les termes «syntaxe», «expression» et «phrase» sont utilisés de manière mixte et peuvent être un peu difficiles à comprendre, donc j'aimerais d'abord expliquer ces trois termes.
Premièrement, la "syntaxe" est une règle pour qu'un programme ait une structure dans son langage de programmation. Il contient souvent des mots clés qui sont traités spécialement dans le langage de programmation, tels que class, val, if, et il existe des règles pour construire le programme correct. Dans le cas de la classe, la classe est suivie du nom de la classe, le contenu de la classe est entouré de {et}, et ainsi de suite. Puisque cette section explique la syntaxe de contrôle de Scala, elle explique les règles de création de programmes qui contrôlent le flux de traitement.
Ensuite, «l'expression» est la partie qui compose le programme et devient une valeur lorsque l'évaluation est réussie. Par exemple, 1 ou 1 + 2, "hoge". En les évaluant, ils deviennent des valeurs numériques ou des valeurs de chaîne de caractères. J'ai utilisé l'expression que l'évaluation a réussi, mais lorsqu'une exception est levée à la suite de l'évaluation, cela correspond au cas où l'évaluation échoue.
Enfin, il y a le «Statement», qui, contrairement à l'expression, est la partie qui compose le programme et qui n'est pas valorisée lors de son évaluation. Par exemple, si la définition d'une variable, val i = 1, est évaluée, la variable i est définie et la valeur de i devient 1, mais cette définition dans son ensemble n'a pas de valeur. C'est donc une phrase.
Scala a plus d'expressions que d'instructions dans des langages procéduraux tels que C et Java. Scala utilise une syntaxe qui utilise plus d'expressions que d'instructions. Cela facilite l'écriture de code facile à comprendre qui élimine autant que possible les états tels que les variables.
Veuillez prêter attention à l'utilisation de ces mots et lire l'explication ci-dessous.
Type de bloc
Dans Scala, si vous entourez une séquence de plusieurs expressions avec {}, l'expression entière devient une expression, mais pour plus de commodité, nous l'appellerons une expression de bloc.
La forme générale du type de bloc est
{ <Équation 1>(;|<nouvelle ligne>) <Équation 2>(;|<nouvelle ligne>) ... }
Ce sera. La liste d'expressions représente les expressions individuelles qui sont évaluées dans l'ordre. Les points-virgules peuvent être omis si les expressions sont séparées par des sauts de ligne. L'expression {} évalue l'expression 1, l'expression 2 ... et la séquence d'expressions dans l'ordre, et renvoie la valeur qui a évalué la dernière expression.
Dans la formule suivante
scala> { println("A"); println("B"); 1 + 2; }
A
B
res0: Int = 3
A et B sont générés, et vous pouvez voir que 3 qui est le résultat de la dernière expression 1 + 2 est la valeur de l'expression {}.
Cela devient important dans la définition de méthode décrite plus loin. Dans Scala
def foo(): String = {
"foo" + "foo"
}
Il est courant de définir une méthode sous la forme de (décrit plus loin), mais ici {} est juste une expression {}, et {} n'est pas inclus dans la syntaxe de la définition de méthode. Cependant, {} dans la syntaxe de définition de classe, etc. fait partie de l'instruction.
si expression
L'expression if est utilisée de la même manière que l'instruction if Java. La syntaxe de l'expression if est la suivante:
if '('<Expression conditionnelle>')' <puis expression> (else <autre expression>)?
L'expression conditionnelle doit être de type Boolean. else
Utilisons la formule if immédiatement.
scala> var age = 17
age: Int = 17
scala> if(age < 18) {
| "Moins de 18 ans"
| } else {
| "18 ans et plus"
| }
res1: String =Moins de 18 ans
De plus, il se présente comme suit lorsqu'il est évalué par une autre phrase. Cette opération est possible car l'âge est une chaîne de caractères variable.
scala> age = 18
age: Int = 18
scala> if(age < 18) {
| "Moins de 18 ans"
| } else {
| "18 ans et plus"
| }
res2: String =18 ans et plus
J'essaie de renvoyer une autre chaîne selon que l'âge de la variable mutable est inférieur à 18.
Toute la syntaxe de contrôle Scala est constituée d'expressions, pas seulement d'expressions if. Autrement dit, il renvoie toujours une certaine valeur. Vous avez peut-être vu l'opérateur ternaire?: Dans des langages tels que Java, mais Scala utilise l'expression if lorsque vous avez également besoin d'une valeur.
De plus, bien que j'aie écrit que sinon peut être omis, dans ce cas, la même valeur que la valeur du type d'unité () est complétée est retournée comme indiqué ci-dessous.
if '(' <Expression conditionnelle> ')' <puis expression> else ()
Le type Unit est équivalent à void en Java et est utilisé lorsqu'il n'y a pas de valeur à renvoyer et qu'il n'a qu'une seule valeur ().
tandis que l'expression
La syntaxe de l'expression while est similaire à celle de Java.
while '(' <Expression conditionnelle> ')'Type de corps
L'expression conditionnelle doit être de type Boolean. L'expression while continue d'évaluer l'expression corporelle tant que l'expression conditionnelle est vraie. Comme l'expression while est également une expression, elle renvoie une valeur, mais comme il n'y a pas de valeur appropriée à renvoyer dans l'expression while, elle renvoie une valeur de type Unit ().
Maintenant, sortons une valeur de 1 à 10 en utilisant l'expression while.
scala> var i = 1
i: Int = 1
scala> while(i <= 10) {
| println("i = " + i)
| i = i + 1
| }
i = 1
i = 2
i = 3
i = 4
i = 5
i = 6
i = 7
i = 8
i = 9
i = 10
Similaire à l'utilisation de l'instruction while en Java. Il existe également une expression do while, mais comme elle est similaire à Java, l'explication est omise. Il n'y a pas de fonction de langage équivalente aux instructions break et continue de Java. Cependant, avec une utilisation appropriée des fonctions d'ordre supérieur décrites ci-dessous, l'interruption et la poursuite ne sont pas nécessaires dans la plupart des cas.
pour l'expression
Scala a une syntaxe de contrôle appelée pour les expressions. Il s'agit d'une syntaxe de contrôle qui peut être utilisée de la même manière que l'extension Java for statement, mais qui possède diverses applications autres que les boucles. Pour comprendre la véritable puissance des expressions for, vous devez connaître les méthodes flatMap, map, withFilter, foreach, mais nous n'expliquerons ici que l'utilisation de base des expressions for.
La syntaxe de base de l'expression for est la suivante:
for '(' (<Générateur>;)+ ')' '<Corps>'
# <Générateur> = x <- <formule>
Vous pouvez utiliser une variable de boucle de n'importe quel nom pour la partie correspondant à la variable x de chaque générateur. Vous pouvez écrire différentes expressions dans l'expression. Gardez à l'esprit, cependant, que vous pouvez utiliser une expression qui représente une plage de nombres, car nous ne pouvons pas tout expliquer pour le moment. Par exemple, 1 à 10 est compris entre 1 et 10 (10 inclus) et 1 jusqu'à 10 est compris entre 1 et 10 (10 inclus).
Utilisons maintenant l'expression for.
scala> for(x <- 1 to 5; y <- 1 until 5){
| println("x = " + x + " y = " + y)
| }
x = 1 y = 1
x = 1 y = 2
x = 1 y = 3
x = 1 y = 4
x = 2 y = 1
x = 2 y = 2
x = 2 y = 3
x = 2 y = 4
x = 3 y = 1
x = 3 y = 2
x = 3 y = 3
x = 3 y = 4
x = 4 y = 1
x = 4 y = 2
x = 4 y = 3
x = 4 y = 4
x = 5 y = 1
x = 5 y = 2
x = 5 y = 3
x = 5 y = 4
Il boucle x de 1 à 5, boucle y de 1 à 4 et génère les valeurs de x et y. Ici, nous n'avons que deux générateurs, mais si vous augmentez le nombre, vous pouvez faire une boucle plusieurs fois.
Ce n'est pas le seul pouvoir de l'expression. Vous pouvez également restreindre uniquement ceux qui remplissent les conditions des variables de boucle. Après jusqu'à, si x! = Y est écrit, mais cela n'est extrait que lorsque x et y ont des valeurs différentes.
scala> for(x <- 1 to 5; y <- 1 until 5 if x != y){
| println("x = " + x + " y = " + y)
| }
x = 1 y = 2
x = 1 y = 3
x = 1 y = 4
x = 2 y = 1
x = 2 y = 3
x = 2 y = 4
x = 3 y = 1
x = 3 y = 2
x = 3 y = 4
x = 4 y = 1
x = 4 y = 2
x = 4 y = 3
x = 5 y = 1
x = 5 y = 2
x = 5 y = 3
x = 5 y = 4
L'expression for peut également être utilisée pour faire quelque chose en traçant les éléments de la collection un par un. Écrivons un processus pour tout sortir en suivant une liste composée de 5 éléments "A", "B", "C", "D", "E".
scala> for(e <- List("A", "B", "C", "D", "E")) println(e)
A
B
C
D
E
En outre, l'expression for peut être traitée pour créer une nouvelle collection. Ajoutons la chaîne Pre à tous les éléments de la liste ci-dessus.
scala> for(e <- List("A", "B", "C", "D", "E")) yield {
| "Pre" + e
| }
res9: List[String] = List(PreA, PreB, PreC, PreD, PreE)
Le point ici est le rendement du mot clé. En fait, la syntaxe for peut être utilisée dans un but complètement différent, traitant et renvoyant les éléments d'une collection à l'aide du mot-clé yield. En particulier, les expressions qui utilisent le mot-clé yield sont parfois appelées pour-compréhension.
expression de correspondance
Une expression de correspondance est une structure de contrôle qui peut exprimer plusieurs branches comme un commutateur Java, mais elle peut faire plus qu'un commutateur. La syntaxe de base de l'expression de correspondance est
<Expression symétrique> match {
(case <modèle> (if <garde>)? '=>'
(<formule> (;|<nouvelle ligne>))*
)+
}
Cependant, c'est parce que les contenus qui peuvent être écrits dans ce "modèle" sont très divers. Tout d'abord, utilisons-le comme un boîtier de commutation Java. Par exemple
scala> val taro = "Taro"
taro: String = Taro
scala> taro match {
| case "Taro" => "Male"
| case "Jiro" => "Male"
| case "Hanako" => "Female"
| }
res10: String = Male
Vous pouvez l'utiliser comme ça. Ici, taro contient la chaîne "Taro", qui correspond à la casse "Taro", donc "Male" est renvoyé. Comme certains d'entre vous l'ont peut-être remarqué ici, l'expression de correspondance renvoie également une valeur. La valeur de l'expression de correspondance est l'évaluation de l'expression sur le côté droit de => du modèle correspondant.
Le modèle peut gérer diverses valeurs telles que des valeurs numériques ainsi que des chaînes de caractères.
scala> val one = 1
one: Int = 1
scala> one match {
| case 1 => "one"
| case 2 => "two"
| case _ => "other"
| }
res11: String = one
Ici, _ apparaît à la place du motif, ce qui équivaut à la valeur par défaut de switch-case et est un motif qui correspond à tout. Ce modèle est appelé le modèle générique. Lors de l'utilisation d'expressions de correspondance, nous utilisons souvent des modèles génériques pour éviter les omissions.
Assemblez un modèle
Ceux qui ont appris les instructions switch-case dans des langages tels que Java et C peuvent trouver étrange que la correspondance de motifs de Scala ne fasse pas ce que l'on appelle un comportement de chute.
"abc" match {
case "abc" => println("first") //Le traitement se termine ici
case "def" => println("second") //Ceci n'est pas affiché
}
Le comportement fall-through des instructions switch-case en langage C était connu pour être plus susceptible de créer des bogues que des avantages. Il est souvent critiqué que Java ait repris le comportement de chute du langage C. C'est pourquoi la correspondance de modèles de Scala n'a pas de comportement de chute, mais il y a un | au cas où vous voudriez combiner plusieurs modèles.
"abc" match {
case "abc" | "def" =>
println("first")
println("second")
}
Extraction de valeurs par correspondance de modèles
Autre que le boîtier de commutation, il existe un moyen de faire correspondre certains des éléments de la collection. Jetons un œil au programme suivant.
scala> val lst = List("A", "B", "C")
lst: List[String] = List(A, B, C)
scala> lst match {
| case List("A", b, c) =>
| println("b = " + b)
| println("c = " + c)
| case _ =>
| println("nothing")
| }
b = B
c = C
Ici, si le premier élément de List est "A" et correspond au modèle de trois éléments, le deuxième élément et les suivants de List sont liés aux b et c restants, et l'expression sur le côté droit de => est évaluée. Devenir. Les expressions de correspondance sont souvent utilisées pour faire correspondre les éléments d'une collection.
Dans la correspondance de modèle, vous pouvez utiliser une expression de garde afin que l'expression du côté droit ne soit pas évaluée à moins qu'elle ne corresponde au modèle et aussi à l'expression de garde (doit être de type booléen).
scala> val lst = List("A", "B", "C")
lst: List[String] = List(A, B, C)
scala> lst match {
| case List("A", b, c) if b != "B" =>
| println("b = " + b)
| println("c = " + c)
| case _ =>
| println("nothing")
| }
nothing
Ici, nous avons spécifié la condition selon laquelle le deuxième élément de List n'est pas "B" dans la condition de garde de correspondance de motif, donc il ne correspond pas à la première condition et correspond à _.
De plus, les modèles de correspondance de modèles peuvent être imbriqués. Modifions un peu le programme précédent pour qu'il corresponde à une liste commençant par List ("A").
scala> val lst = List(List("A"), List("B", "C"))
lst: List[List[String]] = List(List(A), List(B, C))
scala> lst match {
| case List(a@List("A"), x) =>
| println(a)
| println(x)
| case _ => println("nothing")
| }
List(A)
List(B, C)
lst est List("A")Et liste("B", "C")C'est une liste composée de deux éléments. Ici, en utilisant l'expression de correspondance, le début est List("A")Vous pouvez voir que nous pouvons décrire le modèle imbriqué de. Aussi avant le motif@Celui avec est appelé comme motif,@Une expression qui correspond au modèle qui suit@Liez à la variable avant (a dans ce cas). Le motif en tant que motif est utile lorsque vous souhaitez ne découper qu'une partie du motif lorsque le motif est compliqué. pourtant|Notez que la valeur ne peut pas être récupérée pour la correspondance de modèle à l'aide de. Comme décrit ci-dessous|Si vous utilisez une variable dans la correspondance de modèle de, une erreur de compilation se produira.
scala> (List("a"): Any) match {
| case List(a) | Some(a) =>
| println(a)
| }
<console>:14: error: illegal variable in pattern alternative
case List(a) | Some(a) =>
^
<console>:14: error: illegal variable in pattern alternative
case List(a) | Some(a) =>
^
Une correspondance de modèle qui ne récupère pas la valeur est possible.
(List("a"): Any) match {
case List(_) | Some(_) =>
println("ok")
}
Extraction de valeurs à l'aide d'un motif incrusté
Vous pouvez écrire une correspondance de motif comme celle de la section précédente dans une notation différente. Par exemple
scala> val lst = List("A", "B", "C")
lst: List[String] = List(A, B, C)
scala> lst match {
| case List("A", b, c) =>
| println("b = " + b)
| println("c = " + c)
| case _ =>
| println("nothing")
| }
b = B
c = C
Le code peut être réécrit comme suit.
scala> val lst = List("A", "B", "C")
lst: List[String] = List(A, B, C)
scala> lst match {
| case "A" :: b :: c :: _ =>
| println("b = " + b)
| println("c = " + c)
| case _ =>
| println("nothing")
| }
b = B
c = C
Ici, un nom de motif (: :) qui apparaît entre les éléments de la liste, tel que "A" :: b :: c :: _, est appelé un motif en incrustation. Lorsque la correspondance de motif est effectuée par le motif en médaillon (: :), l'élément avant :: pointe vers le premier élément de la liste et l'élément après :: pointe vers le reste de la liste. Si vous souhaitez ignorer la fin de la liste, vous devrez insérer _ à la fin du modèle, comme indiqué ci-dessus. Gardez à l'esprit qu'il existe une telle fonctionnalité, car les modèles de placement de liste sont courants dans la programmation Scala.
Correspondance de motifs par type
Vous pouvez également utiliser un modèle qui ne correspond que si la valeur appartient à un type particulier. Les modèles qui ne correspondent que si la valeur appartient à un type particulier sont utilisés sous la forme de nom: type correspondant. Par exemple, vous pouvez l'utiliser comme ceci: Le type AnyRef est un type équivalent au type d'objet Java, et toute valeur de type référence peut être stockée dans la variable de type AnyRef.
scala> import java.util.Locale
import java.util.Locale
scala> val obj: AnyRef = "String Literal"
obj: AnyRef = String Literal
scala> obj match {
| case v:java.lang.Integer =>
| println("Integer!")
| case v:String =>
| println(v.toUpperCase(Locale.ENGLISH))
| }
STRING LITERAL
Vous pouvez voir qu'il ne correspond pas à java.lang.Integer, mais à une chaîne. Ce modèle est parfois utilisé pour la gestion des exceptions et équivaut à la définition. Les valeurs qui correspondent à un type peuvent être traitées comme si elles avaient été converties en ce type.
Par exemple, v qui correspond au type String dans l'expression ci-dessus peut appeler la méthode de type String toUpperCase. C'est une bonne idée de garder à l'esprit que Scala utilise souvent la correspondance de motifs au lieu de la diffusion.
Pièges de la correspondance de modèle de type en raison des contraintes JVM
Il y a une chose à garder à l'esprit lors de la correspondance de types de modèles. En raison des restrictions de la JVM qui exécute Scala, la correspondance de modèle ne sera pas effectuée correctement lors de l'utilisation de variables de type.
Par exemple, si vous essayez d'effectuer la correspondance de modèle suivante avec REPL, vous obtiendrez un avertissement.
scala> val obj: Any = List("a")
obj: Any = List(a)
scala> obj match {
| case v: List[Int] => println("List[Int]")
| case v: List[String] => println("List[String]")
| }
<console>:16: warning: non-variable type argument Int in type pattern List[Int](the underlying of List[Int]) is unchecked since it is eliminated by erasure
case v: List[Int] => println("List[Int]")
^
<console>:17: warning: non-variable type argument String in type pattern List[String](the underlying of List[String]) is unchecked since it is eliminated by erasure
case v: List[String] => println("List[String]")
^
<console>:17: warning: unreachable code
case v: List[String] => println("List[String]")
^
List[Int]
List [Int] et List [String] sont de types différents, mais la correspondance de modèle ne peut pas les distinguer.
La signification des deux premiers avertissements est que l'action "type erase" du compilateur Scala efface la partie Int de List [Int] et n'est pas vérifiée.
En conséquence, les deux modèles deviennent indiscernables et la correspondance de modèles est effectuée dans l'ordre à partir du haut, de sorte que le deuxième modèle est un code inaccessible. Le troisième avertissement signifie ceci.
Pour la correspondance de modèles de types qui incluent des variables de type, il est recommandé d'utiliser des modèles génériques comme indiqué ci-dessous.
obj match {
case v: List[_] => println("List[_]")
}
fin
La prochaine fois, j'étudierai les cours.
référence
Ce document est CC BY-NC-SA 3.0
Il est distribué sous.
https://dwango.github.io/scala_text/
Aussi, concernant la formule de rendement, etc., il semble bon de continuer l'article suivant.
https://qiita.com/harry0000/items/e37ca3bfb68df839bf55
Recommended Posts