Scala Language
エラー処理

試す

map 、 getOrElse 、およびflatMapでgetOrElseてflatMap ：

import scala.util.Try

val i = Try("123".toInt)     // Success(123)
i.map(_ + 1).getOrElse(321)  // 124

val j = Try("abc".toInt)     // Failure(java.lang.NumberFormatException)
j.map(_ + 1).getOrElse(321)  // 321

Try("123".toInt) flatMap { i =>
  Try("234".toInt)
    .map(_ + i)
}                            // Success(357)

パターンマッチングでTryを使う：

Try(parsePerson("John Doe")) match {
    case Success(person) => println(person.surname)
    case Failure(ex) => // Handle error ...
}

いずれか

エラー/成功のための異なるデータ型

def getPersonFromWebService(url: String): Either[String, Person] = {
    
    val response = webServiceClient.get(url)

    response.webService.status match {
        case 200 => {
            val person = parsePerson(response)
            if(!isValid(person)) Left("Validation failed")
            else Right(person)
        }

        case _ => Left(s"Request failed with error code $response.status")
    }
}

いずれかの値でのパターンマッチング

getPersonFromWebService("http://some-webservice.com/person") match {
    case Left(errorMessage) => println(errorMessage)
    case Right(person) => println(person.surname)
}

いずれかの値をOptionに変換する

val maybePerson: Option[Person] = getPersonFromWebService("http://some-webservice.com/person").right.toOption

オプション

使用null値を強く期待し、従来のJavaコードとの相互作用がない限り、推奨されないnull 。その代わりに、関数の結果が何か（ Some ）または何もない（ None ）のいずれかである場合に、 Optionを使用する必要があります。

try-catchブロックはエラー処理に適していますが、関数が正当に何も返さない場合、 Optionは使いやすく、シンプルです。

Option[T]はSome(value) （ T型の値を含む）またはNone ：

def findPerson(name: String): Option[Person]

人が見つからない場合は、 Noneを返すことができます。それ以外の場合は、 Personオブジェクトを含むSome型のオブジェクトが返されます。次に示すのは、 Optionタイプのオブジェクトを処理する方法です。

パターンマッチング

findPerson(personName) match {
    case Some(person) => println(person.surname)
    case None => println(s"No person found with name $personName")
}

mapとgetOrElseを使う

val name = findPerson(personName).map(_.firstName).getOrElse("Unknown")
println(name) // Prints either the name of the found person or "Unknown"

フォールドを使う

val name = findPerson(personName).fold("Unknown")(_.firstName)
// equivalent to the map getOrElse example above.

Javaへの変換

相互運用性のためにOptionタイプをヌル可能なJavaタイプに変換する必要がある場合：

val s: Option[String] = Option("hello")
s.orNull           // "hello": String
s.getOrElse(null)  // "hello": String

val n: Option[Int] = Option(42)
n.orNull           // compilation failure (Cannot prove that Null <:< Int.)
n.getOrElse(null)  // 42

先物取引のエラー処理

Future中からexceptionがスローされると、それを処理するrecoverを使うことができます。

例えば、

def runFuture: Future = Future { throw new FairlyStupidException }

val itWillBeAwesome: Future = runFuture

... FutureからExceptionを投げる。しかし、 FairlyStupidException型のExceptionが高い確率で発生することを予測することができるので、このケースを具体的にエレガントな方法で処理できます。

val itWillBeAwesomeOrIllRecover = runFuture recover { 
    case stupid: FairlyStupidException => 
         BadRequest("Another stupid exception!") 
}

ご覧のように、 recoverメソッドはすべてのThrowableのドメイン上のPartialFunctionであるため、特定の少数の型だけを処理し、残りの部分をFutureスタックの上位レベルの例外処理のエーテルにすることができます。

これは、 Futureコンテキストで次のコードを実行するのと同様であることに注意してください。

def runNotFuture: Unit = throw new FairlyStupidException

try {
    runNotFuture
} catch {
    case e: FairlyStupidException => BadRequest("Another stupid exception!")
}

Futureの中で生成された例外を処理することは、彼らがもっと潜行性があるので大変重要です。彼らは通常あなたの顔にすべてを得るわけではありません。なぜなら、それらは異なる実行コンテキストとスレッドで実行されるためです。したがって、ログやログに何か気付かない場合には、応用。

try-catch句の使用

以下のような機能的な構成要素に加えてTry 、 OptionおよびEitherエラー処理のため、Scalaはまた、（最終的には、同様にブロック可能性のある）のtry-catch節を使用して、Javaのに似た構文をサポートしています。 catch節はパターンマッチです：

try { 
  // ... might throw exception
} catch {
  case ioe: IOException => ... // more specific cases first
  case e: Exception => ...
  // uncaught types will be thrown
} finally {
  // ...
}

例外をいずれかの型またはオプション型に変換する

例外をEither型またはOption型に変換するには、 scala.util.control.Exceptionで提供されるメソッドを使用できます。

import scala.util.control.Exception._

val plain = "71a"
val optionInt: Option[Int] = catching(classOf[java.lang.NumberFormatException]) opt { plain.toInt }
val eitherInt = Either[Throwable, Int] = catching(classOf[java.lang.NumberFormatException]) either { plain.toInt }