できない.dev

例外を捕捉するには

エラーが起きたときに処理を止めず、その場で受け止めて後続の処理を続ける書き方を各言語で示す。
Python・JavaScript・TypeScript・Java・C# は例外を catch し、Go と Rust は例外を使わず戻り値のエラーを調べる。

公開:

選んだ言語は、ほかのサンプルコードを開いたときも最初に表示する。

Python

try:
    n = int("abc")
except ValueError as e:
    print(f"変換できない: {e}")  # -> 変換できない: invalid literal for int() with base 10: 'abc'
finally:
    print("後始末")  # -> 後始末
 
# except は上から順に照合される。親クラスを先に書くと子クラスの except には届かない
try:
    int("abc")
except Exception:
    print("Exception で受けた")  # -> Exception で受けた
except ValueError:
    print("ここには来ない")

try の中で起きた例外を except で受け取り、as e で例外オブジェクトを使える。
finally は例外の有無にかかわらず必ず実行されるので、後始末に向いている。

JavaScript

try {
  JSON.parse("{abc");
} catch (err) {
  console.log(err.name); // -> SyntaxError
  console.log(err instanceof SyntaxError); // -> true
} finally {
  console.log("後始末"); // -> 後始末
}
 
// throw できるのは Error に限らない。文字列を投げると catch で受け取れるが、スタックトレースは付かない
try {
  throw "文字列を投げた";
} catch (err) {
  console.log(typeof err); // -> string
  console.log(err instanceof Error); // -> false
}

try で起きた例外を catch で受け取り、err.name で種類を、instanceof で型を確かめる。
finally は例外の有無にかかわらず実行される。

TypeScript

try {
  JSON.parse("{abc");
} catch (err: unknown) {
  // err は unknown なので、使う前に型を絞り込む
  if (err instanceof SyntaxError) {
    console.log(err.name); // -> SyntaxError
  } else {
    throw err; // 想定外のエラーは握りつぶさず投げ直す
  }
} finally {
  console.log("後始末"); // -> 後始末
}

catch の変数は unknown 型なので、instanceof で絞り込んでから name や message を読む。
想定外のエラーは握りつぶさず throw err で投げ直すと、原因を見失わない。

できないときTypeScript「'e' is of type 'unknown'」が catch で出る原因と直し方

Go

package main
 
import (
	"fmt"
	"strconv"
)
 
func main() {
	// Go に例外はない。関数が error を戻り値で返すので、呼び出し側で調べる
	_, err := strconv.Atoi("abc")
	if err != nil {
		fmt.Println("変換できない:", err) // -> 変換できない: strconv.Atoi: parsing "abc": invalid syntax
	}
 
	// 後始末は defer で書く
	defer fmt.Println("後始末") // -> 後始末(main を抜けるときに実行される)
}

Go に例外はなく、失敗しうる関数は error を戻り値で返す。
呼び出し側が err != nil を確かめて処理を分ける。
後始末は defer で書く。

Rust

fn main() {
    // Rust に例外はない。失敗しうる関数は Result を返すので、match で Ok と Err を分ける
    match "abc".parse::<i32>() {
        Ok(n) => println!("{}", n),
        Err(e) => println!("変換できない: {}", e), // -> 変換できない: invalid digit found in string
    }
}

Rust に例外はなく、失敗しうる関数は Result を返す。
match で Ok と Err を分けると、失敗の扱いを書き忘れたときにコンパイルエラーになる。

Java

public class Main {
    public static void main(String[] args) {
        try {
            Integer.parseInt("abc");
        } catch (NumberFormatException e) {
            System.out.println("変換できない: " + e.getMessage()); // -> 変換できない: For input string: "abc"
        } finally {
            System.out.println("後始末"); // -> 後始末
        }
    }
}

try の中で起きた例外を、型を指定した catch で受け取る。
finally は例外の有無にかかわらず必ず実行される。

C#

try
{
    int.Parse("abc");
}
catch (FormatException e)
{
    Console.WriteLine($"変換できない: {e.Message}"); // -> 変換できない: The input string 'abc' was not in a correct format.
}
finally
{
    Console.WriteLine("後始末"); // -> 後始末
}

try の中で起きた例外を、型を指定した catch で受け取る。
finally は例外の有無にかかわらず必ず実行される。

例外を使う言語と、戻り値でエラーを返す言語がある

"abc" を整数に変換して失敗させたところ、失敗の伝わり方は言語で 2 通りに分かれた。

  • Python・JavaScript・TypeScript・Java・C# は例外を投げ、catch や except で受け取る。
  • Go は error を戻り値で返し、呼び出し側が if err != nil で調べる。
  • Rust は Result を返し、match で Ok と Err を分ける。

例外を使う言語では、どこにも catch が無ければ例外が呼び出し元へ伝わっていく。
戻り値で返す言語では、受け取って調べるまで失敗が表に出ないので、調べる書き方を省かない。

Python は except の順序で受ける例外が決まる

except は上から順に照合され、最初に当てはまったものだけが実行される。
except Exception を except ValueError より先に書くと、ValueError も先の節で受けられてしまい、後ろの節は実行されなかった。
親クラスの except は子クラスより後ろに書く。

また、except ... as e の変数 e は except ブロックを抜けると削除される。
ブロックの外で e を読むと NameError になるので、必要なら別の変数に入れておく。

TypeScript の catch の変数は unknown になる

strict を有効にすると useUnknownInCatchVariables が有効になり、catch の変数が unknown 型になる。
catch (err) { console.log(err.message); } は 'err' is of type 'unknown'(TS18046)でコンパイルエラーになった。

JavaScript では文字列や数値も throw できるため、catch で受け取る値が Error とは限らない。
instanceof Error などで絞り込んでから使う。

Go の error 値と Rust の Result と panic

Go と Rust は、起きうる失敗を戻り値で表す。
例外のように呼び出し元へ自動では伝わらないので、受け取った側が処理を決める。

  • Go で error を無視すると、失敗に気づかないまま処理が進む。
  • Rust で戻り値の Result を使わずに捨てると、unused Result that must be used の警告が出た。ただしコンパイルは通り、処理はそのまま続いた。

どちらにも、回復できない異常を表す panic がある。
Rust の Err に unwrap をかけると panic になり、終了コードは 101 だった。
Go の nil のマップへの書き込みも panic になるが、defer の中で recover を呼ぶと受け止められた。
ただし、通常の失敗の扱いには error と Result を使い、panic は想定外の異常に限る。