できない.dev

独自のエラーを投げるには

業務の意味を持つ独自のエラー型を定義して、条件を満たさないときに投げる書き方を各言語で示す。
例外を継承する言語と、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 以上にする: -1

Exception を継承したクラスを作り、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 を渡している。