独自のエラーを投げるには
業務の意味を持つ独自のエラー型を定義して、条件を満たさないときに投げる書き方を各言語で示す。
例外を継承する言語と、Go と Rust のように専用のインターフェースを実装する言語に分けてまとめる。
公開:
選んだ言語は、ほかのサンプルコードを開いたときも最初に表示する。
Python
class ValidationError(Exception):
"""入力の検証に失敗したときのエラー"""
def check_age(age):
if age < 0:
raise ValidationError(f"age は 0 以上にする: {age}")
return age
try:
check_age(-1)
except ValidationError as e:
print(type(e).__name__, e) # -> ValidationError age は 0 以上にする: -1Exception を継承したクラスを作り、raise で投げる。
独自の型にすると、except ValidationError のように、受け取る側が原因ごとに処理を分けられる。
JavaScript
class ValidationError extends Error {
constructor(message) {
super(message);
this.name = "ValidationError";
}
}
function checkAge(age) {
if (age < 0) throw new ValidationError(`age は 0 以上にする: ${age}`);
return age;
}
try {
checkAge(-1);
} catch (err) {
console.log(err instanceof ValidationError); // -> true
console.log(err.name, err.message); // -> ValidationError age は 0 以上にする: -1
}Error を継承したクラスを作り、super にメッセージを渡して name を設定する。name を設定しておくと、catch したあとにエラーの種類を表示や記録で見分けられる。
TypeScript
class ValidationError extends Error {
constructor(message: string) {
super(message);
this.name = "ValidationError";
}
}
function checkAge(age: number): number {
if (age < 0) throw new ValidationError(`age は 0 以上にする: ${age}`);
return age;
}
try {
checkAge(-1);
} catch (err: unknown) {
if (err instanceof ValidationError) {
console.log(err.name, err.message); // -> ValidationError age は 0 以上にする: -1
}
}Error を継承したクラスを作り、catch では instanceof で絞り込んで使う。catch の変数は unknown 型なので、絞り込まないと name や message を読めない。
Go
package main
import (
"errors"
"fmt"
)
// Error メソッドを持つ型は error として使える
type ValidationError struct {
Field string
}
func (e *ValidationError) Error() string {
return "検証に失敗: " + e.Field
}
func checkAge(age int) error {
if age < 0 {
return &ValidationError{Field: "age"}
}
return nil
}
func main() {
// fmt.Errorf の %w で包んでも、errors.As で中の型を取り出せる
err := fmt.Errorf("登録処理: %w", checkAge(-1))
var ve *ValidationError
if errors.As(err, &ve) {
fmt.Println(ve.Field) // -> age
}
fmt.Println(err) // -> 登録処理: 検証に失敗: age
}Error メソッドを持つ型は error として返せる。fmt.Errorf の %w で包んでも、errors.As で包まれた中の型を取り出せる。
Rust
use std::fmt;
// Display と Error を実装した型は、独自のエラーとして使える
#[derive(Debug)]
struct ValidationError {
field: String,
}
impl fmt::Display for ValidationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "検証に失敗: {}", self.field)
}
}
impl std::error::Error for ValidationError {}
fn check_age(age: i32) -> Result<i32, ValidationError> {
if age < 0 {
return Err(ValidationError { field: "age".to_string() });
}
Ok(age)
}
fn main() {
match check_age(-1) {
Ok(age) => println!("{}", age),
Err(e) => println!("{}", e), // -> 検証に失敗: age
}
}Display と std::error::Error を実装した型を、Result の Err に入れて返す。
呼び出し側は match で Err の中身を読める。
Java
public class Main {
// Exception を継承すると検査例外になる(RuntimeException を継承すると検査されない)
static class ValidationException extends Exception {
ValidationException(String message) {
super(message);
}
}
static int checkAge(int age) throws ValidationException {
if (age < 0) {
throw new ValidationException("age は 0 以上にする: " + age);
}
return age;
}
public static void main(String[] args) {
try {
checkAge(-1);
} catch (ValidationException e) {
System.out.println(e.getClass().getSimpleName() + " " + e.getMessage()); // -> ValidationException age は 0 以上にする: -1
}
}
}Exception を継承すると検査例外になり、投げるメソッドに throws を書く必要がある。
呼び出し側は catch するか、自分も throws で宣言しないとコンパイルできない。
C#
try
{
CheckAge(-1);
}
catch (ValidationException e)
{
Console.WriteLine($"{e.GetType().Name} {e.Message}"); // -> ValidationException age は 0 以上にする: -1
}
static int CheckAge(int age)
{
if (age < 0) throw new ValidationException($"age は 0 以上にする: {age}");
return age;
}
class ValidationException : Exception
{
public ValidationException(string message) : base(message) { }
}Exception を継承したクラスを作り、base にメッセージを渡して throw する。catch (ValidationException e) のように型を指定すると、この種類のエラーだけを受け取れる。
例外を継承する言語と、インターフェースを実装する言語がある
独自のエラーの作り方は、言語で大きく 2 通りに分かれた。
- Python・JavaScript・TypeScript・Java・C# は、例外の基底クラス(
ExceptionやError)を継承する。 - Go は
Error() stringメソッドを持つ型を作る。errorはインターフェースなので、継承は要らない。 - Rust は
Displayとstd::error::Errorを実装した型を作り、ResultのErrで返す。
基底クラスを継承する言語では、継承した型のおかげで catch の型指定で原因ごとに受け分けられる。
Go では errors.As が同じ役割を持つ。
Java の検査例外は throws の宣言を強制される
Java で Exception を継承した型は検査例外になる。
投げるメソッドに throws Exception と書いたまま、呼び出し側で catch も throws もしないと、unreported exception Exception; must be caught or declared to be thrown でコンパイルできなかった。
宣言を強制されたくないときは、RuntimeException を継承して非検査例外にする。
ただし呼び出し側に処理を促す効果は弱くなるので、回復できる失敗には検査例外、プログラムの誤りには非検査例外を使い分ける。
JavaScript と TypeScript は name を設定する
class V extends Error {} で作ったエラーの name は、V ではなく Error のままだった。
クラス名を表示に使いたいときは、コンストラクタで this.name を設定する。
throw できるのは Error に限らないので、catch で受け取った値が独自のクラスかどうかは instanceof で確かめる。
Go では errors.As でエラーの型を取り出す
fmt.Errorf("登録処理: %w", err) で包んだエラーは、表示すると 登録処理: 検証に失敗: age のように文言がつながった。
包まれたあとでも、errors.As(err, &ve) を使うと中の *ValidationError を取り出せて、Field を読めた。
errors.As の第 2 引数には、取り出したい型の変数のアドレスを渡す。
ここでは *ValidationError 型の変数 ve を宣言して &ve を渡している。