Éviter d'utiliser null

La plupart des langages ont un mot-clé ou un objet spécial pour représenter le fait qu'une référence d'objet est « rien ». En Java, c'est null. En Java, null est un mot-clé, pas un objet, donc appeler n'importe quelle méthode dessus est illégal. Mais c'est un choix déroutant pour les concepteurs de langages. Pourquoi renvoyer un mot-clé quand le programmeur s'attend à renvoyer un objet ?

Le type Option de Scala

Afin de rendre l'objectif selon lequel tout est un objet plus cohérent, et de suivre les conventions de la programmation fonctionnelle, Scala vous encourage à utiliser le type Option lorsque les variables et les valeurs de retour de fonctions peuvent ne référencer aucune valeur. Lorsqu'il n'y a pas de valeur, utilisez None, qui est une sous-classe d'Option. S'il y a une valeur à référencer, utilisez Some pour contenir cette valeur. Some est aussi une sous-classe d'Option. None est déclaré comme un objet, pas comme une classe, car nous n'avons besoin que d'une seule instance de celui-ci. De cette façon, il ressemble quelque peu au mot-clé null, mais c'est un véritable objet avec des méthodes.

Exemples d'application

Les valeurs de type Option sont souvent utilisées comme types de retour d'opérations sur les types de collections Scala (List, Map, etc.). Par exemple, la méthode get de Map :

scala> val capitals = Map("France"->"Paris", "Japan"->"Tokyo", "China"->"Beijing")
capitals: scala.collection.immutable.Map[String,String] = Map(France -> Paris, Japan -> Tokyo, China -> Beijing)

scala> capitals get "France"
res0: Option[String] = Some(Paris)

scala> capitals get "North Pole"
res1: Option[String] = None

Option a deux sous-catégories, Some et None. Lorsque le programme renvoie Some, cela signifie que la fonction vous a bien donné une String, et vous pouvez obtenir cette String via la fonction get(). Si le programme renvoie None, cela signifie qu'il n'y a pas de String pour vous.

Lorsqu'il renvoie None, c'est-à-dire lorsqu'il n'y a pas de String pour vous, si vous insistez encore pour appeler get() afin d'obtenir le String, Scala vous lancera également une NoSuchElementException. Nous pouvons aussi choisir une autre méthode, getOrElse. Cette méthode renvoie la valeur correspondante lorsque l'Option est une instance de Some, et renvoie le paramètre transmis lorsqu'il s'agit d'une instance de None. En d'autres termes, le paramètre passé à getOrElse est en fait la valeur de retour par défaut.

scala> capitals get "North Pole" get
warning: there was one feature warning; re-run with -feature for details
java.util.NoSuchElementException: None.get
  at scala.None$.get(Option.scala:347)
  at scala.None$.get(Option.scala:345)
  ... 33 elided

scala> capitals get "France" get
warning: there was one feature warning; re-run with -feature for details
res3: String = Paris

scala> (capitals get "North Pole") getOrElse "Oops"
res7: String = Oops

scala> capitals get "France" getOrElse "Oops"
res8: String = Paris

Séparez la valeur optionnelle au moyen du filtrage par motif. Si la valeur correspondante est Some, extrayez la valeur à l'intérieur de Some et affectez-la à la variable x :

def showCapital(x: Option[String]) = x match {
    case Some(s) => s
    case None => "?"
}

Astuces

Les programmes Scala utilisent très fréquemment Option. En Java, null sert à représenter des valeurs vides, et des vérifications du mot-clé null doivent être ajoutées à de nombreux endroits dans le code, sinon une NullPointerException peut facilement se produire. Par conséquent, les programmes Java doivent se préoccuper des variables qui peuvent être null. La probabilité que ces variables soient null est très faible, mais une fois que cela arrive, il est difficile de découvrir pourquoi une NullPointerException s'est produite. Le type Option de Scala permet d'éviter cette situation, c'est pourquoi les applications Scala recommandent d'utiliser le type Option pour représenter certaines valeurs optionnelles. Avec le type Option, les lecteurs voient d'un coup d'œil que les valeurs de ce type peuvent être None.

En fait, grâce au typage statique de Scala, vous ne pouvez pas essayer par erreur d'appeler une méthode sur une valeur qui peut être null. Bien que ce soit une erreur facile à commettre en Java, elle ne compile pas en Scala. En effet, la pratique de programmation consistant à ne pas vérifier si une variable est null en Java devient une erreur de type en Scala (vous ne pouvez pas utiliser Option[String] comme String). Par conséquent, l'utilisation d'Option encourage fortement des habitudes de programmation plus souples.

Explication détaillée de Option[T]

En Scala, Option[T] est en fait un conteneur, tout comme un tableau ou une List. Vous pouvez le considérer comme une List qui peut avoir zéro ou un élément.

Lorsque votre Option contient quelque chose, la longueur de cette List est 1 (c'est-à-dire Some), et lorsqu'elle ne contient rien, sa longueur est 0 (c'est-à-dire None).

boucle for

Si nous utilisons Option comme une List ordinaire et utilisons une boucle for pour parcourir cette Option, alors si l'Option est None, le code dans la boucle for ne s'exécutera naturellement pas, et nous atteignons ainsi l'objectif de « ne pas avoir à vérifier si l'Option est None ».

scala> val map1 = Map("key1" -> "value1")
map1: scala.collection.immutable.Map[String,String] = Map(key1 -> value1)

scala> val value1 = map1.get("key1")
value1: Option[String] = Some(value1)

scala> val value2 = map1.get("key2")
value2: Option[String] = None

scala> def printContentLength(x: Option[String]) {
     |   for (c <- x){
     |     println(c.length)
     |   }
     | }
printContentLength: (x: Option[String])Unit

scala> printContentLength(value1)
6

scala> printContentLength(value2)

opération map

L'un des concepts clés de la programmation fonctionnelle est la transformation, c'est pourquoi la plupart des langages qui prennent en charge la programmation fonctionnelle prennent en charge une opération appelée map(). Cette opération peut vous aider à appliquer certaines actions au contenu d'un conteneur et à le transformer en un autre nouveau conteneur.

Considérons maintenant comment utiliser la méthode map d'Option pour implémenterlength: xxxLa forme de sortie est :

Calculez d'abord la longueur de la chaîne à l'intérieur du conteneur Option

Ajoutez ensuite le texte "length: " devant la longueur

Enfin, parcourez le conteneur une fois et imprimez ce qu'il contient.

scala> value1.map(_.length).map("length: " + _).foreach(println)
length: 6

scala> value1.map("length: " + _.length).foreach(println)
length: 6

Grâce à cette méthode de « transformation », nous pouvons également obtenir l'effet souhaité, et de même nous n'avons pas besoin de déterminer s'il s'agit de None.

Lien original : https://www.jianshu.com/p/95896d06a94d