Optionswert abrufen oder Ausnahme auslösen

Was ist bei einer Option die idiomatische Methode, um ihren Wert zu ermitteln oder eine Ausnahme auszulösen?

def foo() : String = {
  val x : Option[String] = ...
  x.getOrException()
}

(BEARBEITEN: Dies ist nicht die beste oder idiomatischste Art, dies zu tun. Ich habe es geschrieben, als ich mit Scala nicht vertraut war. Ich lasse es hier als Beispiel dafür, wie man es nicht macht. Heutzutage würde ich es als @TravisBrown tun.)

Ich denke, es läuft wirklich auf zwei Dinge hinaus:

• Wie sicher bist du dir, dass der Wert da ist?
• Wie möchten Sie reagieren, wenn dies nicht der Fall ist?

Wenn Sie zu diesem Zeitpunkt in Ihrem Code erwarten , dass der Wert vorhanden ist, und in dem Remote-Fall, dass Ihr Programm nicht schnell fehlschlagen soll , würde ich nur einen normalen Vorgang ausführen getund Scala einen auslösen lassen, NoSuchElementExceptionwenn kein Wert vorhanden wäre ::

def foo (): String = {
  val x: Option [String] = ...
  x.get
}}

Wenn Sie den Fall anders behandeln möchten (werfen Sie Ihre eigene Ausnahme), würde ein eleganterer Weg meiner Meinung nach so aussehen:

def foo (): String = {
  val x: Option [String] = Keine
  x Übereinstimmung {
    case Some (Wert) => Wert
    case None => neue MyRuntimeException auslösen ("blah")
  }}
}} 

Und natürlich, wenn Sie Ihren eigenen alternativen Wert für den Fall angeben möchten, dass der Optionist , den NoneSie nur verwenden würden getOrElse:

def foo (): String = {
  val x: Option [String] = Keine
  x.getOrElse ("mein alternativer Wert")
}} 

Eine throw"Anweisung" ist wirklich ein Ausdruck in Scala und hat einen Typ Nothing, der ein Subtyp jedes anderen Typs ist. Dies bedeutet, dass Sie einfach nur alt verwenden können getOrElse:

def myGet[A](oa: Option[A]) = oa.getOrElse(throw new RuntimeException("Can't."))

Das solltest du aber wirklich, wirklich nicht tun.

Verwenden Sie einfach die .get-Methode.

def get[T](o:Option[T]) = o.get

Es wird eine NoSuchElementException ausgelöst, wenn o eine Instanz von None ist.

Grundsätzlich würde ich mit Optionen wie diesen arbeiten:

def addPrint(oi:Option[Int]) = oi.map(_+1).foreach(println)
addPrint(Some(41))
addPrint(Some(1336))
addPrint(None)

um Ihre spezifische Frage zu vermeiden.

Ich hoffe, dies hilft Ihnen zu verstehen, wie Fehler (und allgemein Effekte) mithilfe von Typen dargestellt werden.

Fehlerbehandlungsstrategien in der funktionalen Scala

• Verwenden Sie Optiondiese Option, um optionale Werte zurückzugeben. Beispiel : Entität im Speicher kann nicht gefunden werden.

• Verwenden Sie Option(possiblyNull)diese Option , um Instanzen von zu vermeiden Some(null).

• Verwenden Sie Either[Error, T]diese Option , um den erwarteten Fehler zu melden. Beispiel : Das E-Mail-Format ist falsch, es kann keine Zeichenfolge auf eine Zahl analysiert werden usw.

• Modellieren Sie Ihre Fehler als ADTs (einfach als Typhierarchien bezeichnet ), um sie beispielsweise links von den beiden zu verwenden, um komplexere Fehlerszenarien darzustellen.

• ExceptionNur werfen , um unerwartete und nicht behebbare Fehler zu signalisieren. Wie fehlende Konfigurationsdatei.

• Verwenden Sie Either.catchOnlyoder Tryoder Cats.IO(erweitert) anstelle eines Catch-Blocks, um unerwartete Fehler zu behandeln. Hinweis: Sie können ADT weiterhin verwenden , diese jedoch von Wurfobjekten aus erweitern. Mehr über EithervsTry .

• Verwenden Sie den ValidatedDatentyp aus Cats lib, um Fehler zu akkumulieren, anstatt ausfallsicher zu sein ( Either). Bevorzugen Sie jedoch entweder auf Modulebene, um die Zusammensetzung des Programms zu vereinfachen (um dieselben Typen zu haben). Zum Beispiel - Formulardatenvalidierung, Anhäufung von Analysefehlern.

• Verwenden Sie die genannten Typen und optimieren Sie das Programm nicht präventiv - da Engpässe höchstwahrscheinlich in der Geschäftslogik und nicht in den Effekttypen enthalten sind.

Ein solcher Ansatz vereinfacht die Wartung und Aktualisierung Ihres Codes, da Sie darüber nachdenken können, ohne auf Implementierungsspezifikationen (auch bekannt als lokales Denken) einzugehen. Außerdem - Fehler reduzieren - können Sie einen Fehler im Typ nicht übersehen. Ausrichten und das Programm leichter (mit Hilfe von map, flatMapund anderen combinators) - da sie auf Typ - Ebene einfacher sind, und nicht mit nicht-lokalen Ausnahmen und Nebenwirkungen.
Weitere Informationen zum Erlernen der funktionalen Scala.

Beachten Sie jedoch, dass sich bei diesem Ansatz manchmal Typen stapeln und es schwieriger werden kann, Dinge zu komponieren. Gegeben zum Beispiel: x: Future[Either[Error, Option[T]]]Was Sie tun können:

• Verwenden Sie mapund flatMapin Kombination mit dem Mustervergleich, um verschiedene Werte solcher Typen zu erstellen, zum Beispiel:

x.faltMap { case Right(Some(v)) => anotherFuture(v); case Left(er) => ... }

• Wenn es nicht hilft, können Sie versuchen, MonadTransformers zu verwenden (keine Angst vor dem Namen, es sind nur Wrapper um die Effekttypen wie "Entweder" oder "Zukunft").
• Eine Möglichkeit besteht auch darin, Ihre ADT-Fehler zu vereinfachen, indem Sie sie aus dem Throwable erweitern, um sie mit Future zu vereinheitlichenFuture[Option[T]]

Und schließlich ist in Ihrem Fall eine Option:

def foo() : Either[Error, String] = {
    val x : Option[String] = ...
    x match {
        case Some(v) => Right(v)
        case None => Left(Error(reason))
    }
}

Scala unterstützt diesen Vorgang jetzt auf Karten mithilfe der getOrElse()Methode (siehe Dokumentation hier)

Wie bereits erwähnt, ist das Auslösen einer Ausnahme in Scala ebenfalls ein Ausdruck.

Sie können also Folgendes tun:

myMap.getOrElse(myKey, throw new MyCustomException("Custom Message HERE")