例外を捕捉するには
エラーが起きたときに処理を止めず、その場で受け止めて後続の処理を続ける書き方を各言語で示す。
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 で投げ直すと、原因を見失わない。
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 は想定外の異常に限る。