Scala return boolean avec if else

Donc je dois scénario suivant:

 def check(): Boolean = {
    for ((digit1,digit2,digit3) <- SetOfDigits){
      if ((1,2,5) == (digit1,digit2,digit3))
        true
      else
        false
}
  }

val SetOfDigits = Set((0,2,3),(1,5,6),(7,10,2),(1,2,5))

Maintenant, le problème est que la fonction doit retourner un Booléen, mais il me dit toujours que le type de retour ici est Unit?
La fonction doit effectuer une itération sur les SetOfDigits et si il trouve quelque chose d'égal comme (1,2,5) il doit retourner true sinon false?
Personne n'a une réponse à ce problème et ce que je dois faire pour le faire fonctionner?

OriginalL'auteur Bajro | 2015-12-12

9

Je ne suis pas d'accord avec la solution de M. V., j'aimerais plutôt vous suggérer de changer votre mise en œuvre, qui semble très Javish façon de gérer les choses:
```
scala> val SetOfDigits = Set((0,2,3),(1,5,6),(7,10,2),(1,2,5))
SetOfDigits: scala.collection.immutable.Set[(Int, Int, Int)] = Set((0,2,3), (1,5,6), (7,10,2), (1,2,5))

scala>   SetOfDigits.contains((1, 2, 5))
res0: Boolean = true

scala>   SetOfDigits.contains((1, 2, 4))
res1: Boolean = false
```
contains trouver un élément dans votre jeu, si l'élément n'est pas là, elle retourne false, à la recherche beaucoup mieux, à mon avis.

En réponse à votre commentaire, j'avais aplatir le premier de la liste, puis utilisez forAll et contains:
```
scala> val setOfDigits1 = Set((0,2,3),(1,5,6),(7,10,2),(1,2,5)).flatMap { case(a,b,c) => Set(a,b,c)}
setOfDigits1: scala.collection.immutable.Set[Int] = Set(0, 5, 10, 1, 6, 2, 7, 3)

scala>   val setOfDigits2 =  Set(1,2,3,16,20,7)
setOfDigits2: scala.collection.immutable.Set[Int] = Set(20, 1, 2, 7, 3, 16)

scala>   val setOfDigits3 =  Set(1,2,3,10)
setOfDigits3: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 10)

scala>   setOfDigits2.forall(i => setOfDigits1.contains(i))
res8: Boolean = false

scala>   setOfDigits3.forall(i => setOfDigits1.contains(i))
res9: Boolean = true
```
Remarque que j'ai flattend la première liste à partir d'un List[(Int, Int, Int)] à un List[Int], puis forAll de l'évaluation d'un prédicat qui doit être vraie pour tous les éléments et contains fait le reste.

Bon ça a fonctionné maintenant, pour moi, mais j'ai une autre question! Disons que ma liste SetOfDigits contient les tuples comme la vôtre ci-dessus, et je veux le comparer à un autre Jeu qui contient: Set(1,2,3,16,20,7)... Comment puis-je le rendement vrai si tous les chiffres qui sont dans SetOfDigits apparaître qu'une fois dans l'autre, de sorte que seulement ceux qui contiennent tous les deux et d'ignorer les autres?
J'ai fait un edit, la réponse était trop long pour un commentaire.

OriginalL'auteur Ende Neu
3

Vous devez ajouter return déclaration avant le vrai ou false pour s'arrêter sur la première exécution.

Sinon, vous pouvez utiliser yield à recueillir les résultats de chaque sous-ensemble (vous obtiendrez la liste de Booléens)

Dépend quelle est votre attente. Si vous voulez vous assurer que au moins sur des sous-ensembles de résultats satisfaisants, votre fonction ressemble à ce qui suit:
```
def check(): Boolean = {
    val s = for ((digit1,digit2,digit3) <- SetOfDigits) {
      if ((1,2,5) == (digit1,digit2,digit3))
        return true
    }
    false
  }
```
OriginalL'auteur vvg
2

Comme mentionné précédemment, le rendement, le résultat de l' if-else, sinon la compréhension renvoie Unit. D'une manière similaire à @EndeNeu de l'API de base de la méthode, de tenir également compte de la
```
xs.exists( _ == (1,2,5) )
Boolean = true
```
qui arrête l'itération sur la collecte ainsi que le premier match est trouvé.

Noter également, par convention, l'étiquette d'une collection commence par une lettre minuscule, à savoir setOfDigits au lieu de SetOfDigits, tandis que les types et les classes sont capitalisés.

OriginalL'auteur elm
2

Je suis d'accord avec Ende Neu réponse.

Dans le cas général, vous pouvez introduire une variable booléenne que vous vérifiez à l'intérieur de la pour-de la compréhension pour y mettre fin prématurément. Je la préfère sur l'aide de la return mot-clé.
```
def check(): Boolean = {
  var found = false
  for ((digit1,digit2,digit3) <- SetOfDigits if !found) {
    if ((1,2,5) == (digit1,digit2,digit3)) found = true
  }
  found
}
```
C'est juste de la mauvaise programmation de passer par l'ensemble de la liste lorsque vous devez interrompre lors de la découverte de la valeur requise. Vrai, return n'est pas idiomatique à la Scala, mais ne sont pas non mutable variables.

OriginalL'auteur Kigyo

Vous devez vous connecter pour publier un commentaire.