Scala verwendet Option, Some, None, um die Verwendung von null zu vermeiden

Vermeiden Sie die Verwendung von null

Die meisten Sprachen haben ein spezielles Schlüsselwort oder Objekt, um darzustellen, dass eine Objektreferenz "nichts" ist. In Java ist es null. In Java ist null ein Schlüsselwort, kein Objekt, daher ist es unzulässig, eine beliebige Methode darauf aufzurufen. Aber das ist eine verwirrende Wahl für Sprachdesigner. Warum ein Schlüsselwort zurückgeben, wenn der Programmierer erwartet, ein Objekt zurückzubekommen?

Scalas Option-Typ

Um das Ziel, dass alles ein Objekt ist, konsequenter umzusetzen und den Konventionen der funktionalen Programmierung zu folgen, ermutigt Scala Sie, den Option-Typ zu verwenden, wenn Variablen und Funktionsrückgabewerte möglicherweise auf keinen Wert verweisen. Wenn es keinen Wert gibt, verwenden Sie None, eine Unterklasse von Option. Wenn es einen Wert gibt, auf den verwiesen werden soll, verwenden Sie Some, um diesen Wert zu enthalten. Some ist ebenfalls eine Unterklasse von Option. None wird als Objekt und nicht als Klasse deklariert, weil wir nur eine einzige Instanz davon benötigen. Auf diese Weise ähnelt es etwas dem null-Schlüsselwort, ist aber ein echtes Objekt mit Methoden.

Anwendungsbeispiele

Werte vom Typ Option werden häufig als Rückgabetypen von Operationen auf Scala-Collection-Typen (List, Map usw.) verwendet. Zum Beispiel die get-Methode von 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 hat zwei Unterkategorien, Some und None. Wenn das Programm Some zurückgibt, bedeutet das, dass die Funktion Ihnen erfolgreich einen String geliefert hat, und Sie können diesen String über die Funktion get() abrufen. Wenn das Programm None zurückgibt, bedeutet das, dass es keinen String für Sie gibt.

Wenn es None zurückgibt, das heißt, wenn es keinen String für Sie gibt, und Sie trotzdem darauf bestehen, get() aufzurufen, um den String zu erhalten, wirft Scala Ihnen ebenfalls eine NoSuchElementException. Wir können auch eine andere Methode wählen, getOrElse. Diese Methode gibt den entsprechenden Wert zurück, wenn die Option eine Instanz von Some ist, und gibt den übergebenen Parameter zurück, wenn sie eine Instanz von None ist. Mit anderen Worten: Der an getOrElse übergebene Parameter ist tatsächlich der Standardrückgabewert.

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

Trennen Sie den optionalen Wert durch Musterabgleich. Wenn der abgeglichene Wert Some ist, extrahieren Sie den Wert innerhalb von Some und weisen Sie ihn der Variablen x zu:

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

Tipps

Scala-Programme verwenden Option sehr häufig. In Java wird null verwendet, um leere Werte darzustellen, und an vielen Stellen im Code müssen Prüfungen auf das null-Schlüsselwort hinzugefügt werden, sonst kann leicht eine NullPointerException auftreten. Daher müssen Java-Programme darauf achten, welche Variablen null sein können. Die Wahrscheinlichkeit, dass diese Variablen null sind, ist sehr gering, aber wenn es passiert, ist es schwierig herauszufinden, warum eine NullPointerException aufgetreten ist. Der Option-Typ von Scala kann diese Situation vermeiden, daher wird in Scala-Anwendungen empfohlen, den Option-Typ zu verwenden, um einige optionale Werte darzustellen. Mit dem Option-Typ können Leser auf einen Blick sehen, dass Werte dieses Typs None sein können.

Tatsächlich können Sie dank der statischen Typisierung von Scala nicht versehentlich versuchen, eine Methode für einen Wert aufzurufen, der null sein könnte. Obwohl dies in Java ein leicht zu machender Fehler ist, lässt es sich in Scala nicht kompilieren. Das liegt daran, dass die Programmierpraxis, in Java nicht zu prüfen, ob eine Variable null ist, in Scala zu einem Typfehler wird (Sie können Option[String] nicht als String verwenden). Daher fördert die Verwendung von Option deutlich flexiblere Programmiergewohnheiten.

Ausführliche Erklärung von Option[T]

In Scala ist Option[T] tatsächlich ein Container, genau wie ein Array oder eine List. Sie können es sich als eine List vorstellen, die null oder ein Element haben kann.

Wenn deine Option etwas enthält, ist die Länge dieser List 1 (das heißt Some), und wenn deine Option nichts enthält, ist ihre Länge 0 (das heißt None).

for-Schleife

Wenn wir Option wie eine gewöhnliche List verwenden und eine for-Schleife benutzen, um über diese Option zu iterieren, dann wird der Code in der for-Schleife, wenn die Option None ist, natürlich nicht ausgeführt, und so erreichen wir das Ziel, "nicht prüfen zu müssen, ob die Option None ist".

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)

map-Operation

Eines der Kernkonzepte in der funktionalen Programmierung ist die Transformation, daher unterstützen die meisten Sprachen, die funktionale Programmierung unterstützen, eine Operation namens map(). Diese Operation kann dir helfen, einige Aktionen auf den Inhalt eines Containers anzuwenden und ihn in einen anderen neuen Container zu verwandeln.

Nun betrachten wir, wie man die map-Methode von Option verwendet, umlength: xxxDie Ausgabeform ist:

Berechne zuerst die Länge des Strings im Inneren des Option-Containers

Füge dann den Text "length: " vor der Länge hinzu

Zum Schluss iteriere einmal durch den Container und gib aus, was sich darin befindet.

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

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

Durch diese "Transformation"-Methode können wir ebenfalls den gewünschten Effekt erzielen, und ebenso müssen wir keine Entscheidung darüber treffen, "ob es None ist".

Original-Link: https://www.jianshu.com/p/95896d06a94d