Convertir l'option [x] en x dans Scala

J'ai travaille avec jouer pour scala (2.1) et j'ai besoin de convertir une "Option[Long]" la valeur de "Long".

Je sais comment faire le contraire, je veux dire:

  def toOption[Long](value: Long): Option[Long] = if (value == null) None else Some(value)

Mais dans mon cas, je dois passer une valeur de "l'Option[Long]" comme un type dans une méthode qui prend un "Long".
Toute aide, s'il vous plaît.

source d'informationauteur mahoosh

22

Tout d'abord, votre mise en œuvre de "l'autre" a des problèmes plus sérieux. En mettant un type de paramètre nommé Long sur la méthode de l'ombre à la Long type de la bibliothèque standard. Tu veux sans doute dire ce qui suit:
```
def toOption(value: Long): Option[Long] =
  if (value == null) None else Some(value)
```
Même c'est le genre de non-sens (depuis scala.Long n'est pas un type de référence et ne peut jamais être null), sauf si vous faites allusion à l' java.lang.Longce qui est une recette pour la douleur et la confusion. Enfin, même si nous avions affaire à un type de référence (comme String), vous seriez mieux de l'écriture de la suite, qui est exactement équivalente:
```
def toOption(value: String): Option[String] = Option(value)
```
Cette méthode sera de retour None si et seulement si value est null.

À répondre à votre question, supposons que nous avons la méthode suivante:
```
def foo(x: Long) = x * 2
```
Vous ne devriez pas généralement à penser en termes de passage d'un Option[Long] à foomais plutôt de "levage" foo dans le Option via map:
```
scala> val x: Option[Long] = Some(100L)
x: Option[Long] = Some(100)

scala> x map foo
res14: Option[Long] = Some(200)
```
Le point de l'ensemble de Option est de modèle (au niveau du type) la possibilité d'une valeur "null, afin d'éviter toute une classe de NullPointerException-y les problèmes. À l'aide de map sur le Option vous permet d'effectuer des calculs sur la valeur que peut-être dans le Option tout en continuant à le modèle de la possibilité qu'elle est vide.

Comme une autre réponse, il est également possible d'utiliser getOrElse de "renflouer" de la Optionmais ce n'est généralement pas le idiomatiques approche en Scala (sauf dans les cas où il est vraiment raisonnable de la valeur par défaut).
31

Si vous avez des x comme Option[Long], x.get vous donnera une Longue.
6

Cette méthode est déjà défini sur l'Option[A] et est appelé obtenir :
```
scala> val x = Some(99L)
x: Some[Long] = Some(99)

scala> x.get
res0: Long = 99
```
Le problème est que l'appel de get sur Aucun allons jeter un NoSucheElement Exception:
```
scala> None.get
java.util.NoSuchElementException: None.get
```
donc vous ne pourrez pas bénéficier des avantages de l'utilisation d'une Option de type.

Ainsi, comme indiqué précédemment, vous pouvez utiliser getOrElse si vous pouvez fournir une valeur par défaut raisonnable de la valeur ou de traiter l'Exception.

La idiomatiques scala façon serait d'utiliser une carte ou une compréhension
```
x map (_ + 1)
res2: Option[Long] = Some(100)
```
ou
```
for (i <- x) yield i +1
res3: Option[Long] = Some(100)
```
2

Option est la façon de le localiser effet de bord de votre fonction peut renvoyer une valeur vide). Et le bon style pour vous remonter le calcul de l'Option (l'Option est Monade avec carte & flatMap méthodes).
```
val x = Option[Long](10) 
x.map { a => a + 10 }
```
Et en extraire la valeur manuellement le traitement d'un effet secondaire:
```
val res = x match {
  case Some(a) => s"Value: $a"
  case None    => "no value"
} 
```

Vous devez décider ce qui se passe lorsque l'option est None. Ne vous fournir une valeur par défaut?

def unroll(opt: Option[Long]): Long = opt getOrElse -1L  //-1 if undefined

unroll(None) //-> -1

Vous pouvez également lancer une exception:

def unroll(opt: Option[Long]): Long = opt.getOrElse(throw 
  new IllegalArgumentException("The option is expected to be defined at this point")
)

unroll(None) //-> exception

En cas, de s'abstenir de l'utilisation de nullsauf si vous avez de très bonnes raisons de l'utiliser (opt.orNull).

0

Comme cela a déjà été mentionné getOrElse est probablement ce que vous cherchez à répondre directement à votre question.

Veuillez noter également que pour le convertir en option, vous pouvez tout simplement:
```
val myOption = Option(1)
```
mon option sera désormais Certains(1)
```
val myOption = Option(null)
```
mon option sera désormais Aucun.

Vous devez vous connecter pour publier un commentaire.